python23 xml模块 面向对象的概念：类；对象

  

复习

 

 

1.configparser解析配置文件

1.1.创建解析对象

c=configparser.ConfigParser

c.read("文件")

c.get("分区"，"选项")

 

2.subprocess子进程

开启进程是为了让完成某项任务

进程间都是相互独立 不能直接交换数据需要交换管道

管道是用于进程间通讯的

out输出管道

in输入管道

err错误输出管道

 

3.表格处理xlrd|xlwt

3.1xlrd读取表格数据******

3.1.1.打开一个文档

open_workbook(文件路径)

3.1.2获得一个sheet

workbook.sheet_by_index/name

3.1.3sheet.cell/row/col

获取行数nrows和列数ncols

3.2xlwt写入数据到表格 了解即可

 

 

今日内容

xml模块

面向对象概念

类（class:属性即特征）

对象（函数：技能即方法）

 

1.xml模块

1.1XML全称：可扩张标记语言

1.1.1基本概念认知

<tag></tag>  双标签

<tag/>  单标签 没有文本

一般用于文档结构 

<tr/>表示换行

 

1.1.2标签的组成：

<tag style="color:red" age="18">12345</tag>

一个标签的完整组成 有三部分：

tag 是标签名称

12345 是文本的内容 text

style="color:red" 是标签的属性

 

 

1.2.其他规范：

1.2.1.有开始就必须有结束

1.2.2.所有属性值必须包含在双引号里面

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

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

1.2.5.文档声明可以不写 主要是告诉浏览器 该怎么解析这个文件

注意：xml模块是自带的不需要安装

 

1.3与joson的区别

       1.3.1 xml是一种可扩展的标记语言

         特征：（属性）——>因为

              可以高度自定义文档的结构 数据类型 标签的含义等等

           所以可扩展性远比json强

        用途：xml更多用来作为配置文件 当然python不太常用

                 html就是一种xml

       1.3.2json更适合于前后台数据交换

           优点 ：

                轻量级 跨平台 语法简洁

          用途：传输

 1.4代码实操：

1.4.1导入模块：

import xml.etree.ElementTree as ET

#import xml.etree.ElementTree正常导入#as ET起别名

 

1.4.2#打开一个文档 得到一个元素树（XML文档）

tree = ET.parse("test1.xml")

 

1.4.3# 获取根标签

root = tree.getroot()

 

1.4.4# 遍历出root标签的所有子标签

# for tag in root:

   # print(tag)

 

1.4.5# 遍历出文档中所有标签

# for tag in root.iter():

     # print(tag))

 

1.4.6# 从root下查找第一个名字为country的子标签

# country = root.find("country")

 # print(country)

 

1.4.7# 从root下查找所有名字为country的子标签

# countrys = root.findall("country")

# print(countrys)

 

1.4.8# 从root下查找所有名字为country的子孙标签

# for tag in root.iter("country"):

       # print(tag)

 

1.5解析xml得到一个tree对象后 查找标签的4种方式

 

1.5.1.iter()
    如果没有参数则查找所有标签
    如果有参数则查找所有名字匹配的标签
    查找范围 为全文
   
1.5.2.find()
    必须给参数
    查找当前标签的子标签  返回第一个名字匹配的
   
1.5.3.findall()
    必须给参数
    查找当前标签的子标签  返回所有名字匹配的

1.5.4.直接遍历某个标签
    返回的是这个标签的所有子标签 

 

1.6案列：

 

文件：text1.xml

<data>
<country name="Liechtenstein">123<rank updated="yes">2</rank>
<year>2010</year>
<gdppc>141100</gdppc>
<neighbor direction="E" name="Austria" />
<neighbor direction="W" name="Switzerland" />
<country>123</country>
</country>
<country name="Singapore">
<rank updated="yes">5</rank>
<year>2013</year>
<gdppc>59900</gdppc>
<neighbor direction="N" name="Malaysia" />
</country>
<country name="Panama">
<rank updated="yes">69</rank>
<year>2013</year>
<gdppc>13600</gdppc>
<neighbor direction="W" name="Costa Rica" />
<neighbor direction="E" name="Colombia" />
</country>
</data>

1.6.2.获取某个标签的详细内容.py——查

做法：

import xml.etree.ElementTree as ET

tree = ET.parse("test1.xml")
root = tree.getroot()

# 找到所有的country标签

es = root.findall("country")
# 获取某个标签的 标签名 属性 以及文本
# for e in es:
# print(e.tag) # 标签名称
# print(e.attrib) # 标签的所有属性 返回一个字典
# print(e.text) # 标签的文本内容

#获取所有国家的 邻居的名称
# for c in es:
# print("%s的邻居如下:" % c.attrib.get("name"))
# for n in c.findall("neighbor"):
# print(n.attrib.get("name"))
# print("更新时间:%s" % c.find("year").text)
# print("===================================")





1.6.3.修改标签的某个属性.py

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("test2.xml",encoding="utf-8",xml_declaration=True)


# 把test1.xml 中所有year标签的text加1
# tree = ET.parse("test1.xml")
# root = tree.getroot()
# for e in root.iter("year"):
# e.text = str(int(e.text) + 1)

# tree.write("test1.xml")


1.6.4# 把test1.xml 中所有gdppc删除
# remove 函数 需要一个标签作为参数 即要被删除的标签 然后只能有父标签来删除子标签
# tree = ET.parse("test1.xml")
# root = tree.getroot()

# for c in root.iter("country"):
# gdppc = c.find("gdppc")
# if gdppc != None:
# c.remove(gdppc)

# tree.write("test4.xml")


1.6.5# 添加标签--贴加标签

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("test5.xml") # 写入文件




4.代码生成xml文档.py

import xml.etree.ElementTree as et
# 创建标签

tag = et.Element("data")
tag.text = "123"
tag.set("name","jack")

# 创建一个元素树 并把tag添加到上面
tree = et.ElementTree(tag)
tree.write("test6.xml")




2.面向对象编程概念

2.1.面向对象
2.1.1.面向过程编程思想

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


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

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

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


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


2.2什么是对象?

万事万物都是对象

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

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


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

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


2.3.1.类的使用.py

"""
使用class关键字来定义一个类

类名称为大驼峰命名法
所有单词首字母大写
小驼峰 第一个单词首字母小写
"""
# class ClassName:
# pass

class Student:
# 描述特征使用变量 (属性)
school = "olbBoy"

# 描述技能使用函数 (方法)
def say_hi():
print("hello i am tiger")

# class中的代码仅在第一次加载时执行
print("test...")
pass

#
print(Student.say_hi)
Student.say_hi()
print(Student.school)

# Student.say_hi()


# 调用类来获得一个对象
# stu1 = Student()
# stu1.say_hi()


2.3.2.对象的使用.py

class Person:
country = "china"

def eat(self):
print("正在吃面...")


p1 = Person()
# print(p1)
# print(Person)

# print(p1.country)
# p1.eat()

# 为对象增加了属性
p1.name = "张三"
print(p1.name)


# 给p1对象单独添加了country
p1.country = "USA"
# 在访问时优先访问自己名称空间的内容 如果找不到 会自动找类中的属性
print(p1.country)
print(Person.country)

# 每个对象都会存储自己所在类的地址 可以使用__class__来访问
print(p1.__class__)
print(type(p1))

# 查看名称空间中的内容
print(p1.__dict__)
print(Person.__dict__)

总结：

 今天讲到的知识点

xml模块

tree=ElemenTree.parser("文件")

root=tree.gretroot()

#增

root.append(标签对象)

#删

root.remove(标签对象)

#修改

root.text="新值“

root.tag="新名字"

root.set("key","value")

tree.write()

#查

root.iter/find/findall

 

 

面向对象

1.什么是面向对象?

2.面向对象与面向过程的优缺点对比以及场景对比

3.什么是对象？什么是类？

4.类和对象的关系

5.如何定义一个类

6.如何创建对象

7.属性的访问顺序

8.类和名称空间是独立