四大模块补充总结 与面向对象总结
常用模块补充
1.configparser:配置文件解析
2.subprocess子进程
3.表格处理：
xlrd 用于读取表格数据
xlwt 用于写数据到表格中
4.xml模块用于解析xml文档
xml 可扩展标记语言
1.configparser:配置文件解析
案例说明：
import configparser
c = configparser.ConfigParser()
c.read("myconf.cfg",encoding="utf-8")
res = c.get("atm","errcount")
# c.getint()
# c.getfloat()
# c.getboolean()
print(res)
c.set("atm","errcount","4")
c.add_section("newsection")
with open("new.cfg","wt",encoding="utf-8") as f:
c.write(f)
2.subprocess子进程
subprocess 子进程
一个正在运行的程序称之为进程
进程之间存在子父关系
之所以开启子进程是为了 让子进程帮我完成某个任务
进程在内存中 是相互隔离的 无法直接访问 需要使用管道
可以理解为用于执行系统指令的
"""
import subprocess
# p = subprocess.Popen("ipconfigs",shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
# print(p.stdout.read().decode("GBK"))
# print(p.stderr.read().decode("GBK"))
p = subprocess.Popen("tasklist",shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
# print(p.stdout.read().decode("GBK"))
p2 = subprocess.Popen("findstr pycharm",shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE,stdin=p.stdout)
print(p2.stdout.read())
# 用subprocess获取硬件信息
3.表格处理：
xlrd 用于读取表格数据
xlwt 用于写数据到表格中
xlrd 用于读取表格数据
xlwt 用于写数据到表格中
都是第三方的 pip install xlrd
都是第三方的 pip install xlwt
表格中有
工作薄 == 一个文件
工作表 == 一个sheet 索引 名称
row == 一行 行号
column == 一列 列号
cell == 一个单元格 行号 列号
案例说明：
"""
import xlrd
book = xlrd.open_workbook("机密数据.xlsx")
sheet = book.sheet_by_index(0)
# print(sheet.row(0))
# print(sheet.row(1))
# print(sheet.row(2))
# print(sheet.row(2)[4].value)
# dates = xlrd.xldate_as_datetime(sheet.row(2)[4].value,0)
# print(str(dates))
# print(sheet.row_values(2))
# print(sheet.nrows)
# print(sheet.ncols)
data = []
keys = sheet.row_values(1)
# print(keys)
for i in range(2,sheet.nrows):
row = sheet.row_values(i)
# print(row)
dic = {}
for k in keys:
if k == "生日":
dic[k] = str(xlrd.xldate_as_datetime(row[keys.index(k)],0))
else:
dic[k] = row[keys.index(k)]
data.append(dic)
print(data)
# # print(sheet.row_values(0))
# print(sheet.merged_cells)
# 将读取数据在写入一个新表格中
import xlwt
book2 = xlwt.Workbook()
sheet = book2.add_sheet("特工信息")
sheet.write_merge(0,0,0,4,"特工信息")
keys = list(data[0].keys())
print(keys)
for k in keys:
sheet.write(1,keys.index(k),k)
row = 2
for d in data:
values = list(d.values())
for k in keys:
col = keys.index(k)
sheet.write(row,col,values[col])
row += 1
book2.save("new.xls")
4.xml模块用于解析xml文档
xml 可扩展标记语言
"""
xml模块用于解析xml文档
xml文档?
xml 可扩展标记语言 是一种扩展非常高的文档格式 数据类型可以自定义 文档结构可以自定义 标签的意义可以自定义
html 格式是基于xml的
<开始标签 属性名称="属性值">文本</结束标签>
只有标签名称是必须的
<标签名/> 不能有文本信息 <br/>
属性值必须在双引号内 不区分类型
最外层只能以后一个标签 称之为根标签
标签的关闭顺序 应该与打开顺序相反 先开的后关 后开的先关
强调 xml 仅仅是一种语法格式 但是一个标签具体是什么含义 你需要自己指定
json 更加适用于 前后台交互 跨平台性强 轻量级
xml 更加适用于 需求更加复杂的场景 ,例如页面编写
配置文件
"""
from xml.etree import ElementTree as ET
tree = ET.parse("test.xml")
root = tree.getroot()
"""
1.iter("") 在全文范围内找名字相同的标签 可以不指定名称 即所有标签
2.find("") 在子标签中查找名字相同的标签 返回第一个
3.findall("") 在子标签中查找名字相同的标签 返回所有
4.直接遍历 一个标签 拿到的是所有子标签
"""
# for e in root.iter("stu"):
# print(e)
# print(e.tag) # 名字
# e.tag = "stu"
# print(e.text) # 文本
# print(e.attrib) # 属性
# e.set("age",str(int(e.get("age"))+1))
# 创建新标签
# e = ET.Element("newtag")
# e.set("name","123321")
# e.text = "嘿嘿!"
#
# root.append(e)
#
#删除标签
for e in root.iter("stu"):
for s in e[:]:
if s.tag == "book":
e.remove(s)
tree.write("test.xml",xml_declaration=True,encoding="utf-8")
面向对象总结：
1.面向对象
"""
面向对象是什么?
是一种编程思想,指导你如何更好的编写代码
关注点在对象
具体存在的,拥有某些特征和行为
类,具备相同特征和相同行为的对象形成的抽象概念
在程序中先有类后有对象
面向过程 中关注的是实现任务具体的过程,即先干啥 再干啥,一种机械化思考方式 像是一个具体的操作者
面向对象 中关注的是对象 ,即实现某个任务需要什么对象 从 一个操作者变成了指挥者
面向对象的优点:
扩展性,复用性,耦合度降低,可维护性强
缺点:
编程的复杂度变高了,容易出现过度设计,无法准确预知道执行结果
使用场景:
当对于扩展性要求较高时,较大的程序应该优先考虑面向对象
面向过程一时爽 重构火葬场
面向过程优点:
将复杂的问题,简单化,流程化
缺点:
扩展性差,维护性变差,
绑定方法:
一个类中的方法默认就是绑定给对象的
对象调用时会自动传入对象本身
也可以绑定给类
@classmethod
当用对象或类调用时都会传入类本身
非绑定方法
@staticmethod
就是一个普通函数 没有自动传值
属性的访问顺序
先访问对象自己的名名称空间 -> 所在类的名称空间 ->父类的名称空间 -> object
"""
class Person:
name = "张三"
def __init__(self,name):
self.name = name
def say_hi(self):
print(self.name)
# def init(obj,name):
# obj.name = name
p = Person("张三")
# print(p.name)
# p.say_hi()
Person.say_hi(p)
# p.name = "李四"
# init(p,"张三!")
"""
2.继承
在程序继承是一种关系,是类与类之间的关系 ,是一种什么是什么的关系
子类可以直接使用父类提供的内容 目的就是减少代码冗余,提高复用性
继承的使用姿势
使用方法1
先抽象
抽取一系列类中相同的特征和行为 形成新的类
再继承
例如老师和学生 可以抽取一个Person类 将相同的姓名 年龄 性别 进行抽取
使用方法2
继承一个已经存在的类 扩展新功能 或修改原有的功能
但是不要忘记 super()调用原来的方法
派生:
子类拥有与父类不同的内容
子类出现了与父类名称完全一致的内容 父类的将被覆盖
子类访问父类的内容
super().__init__(name,age,gender)
python支持多继承
新式:类直接或间接继承了object的类 py3都是新式类
经典类 不是object的子类 仅在py2中存在
问题: 多个父类中出现了相同的名字时,到底用哪个?
新式类可以通过类名.mro()来查看顺序
如是经典类 是深度优先
唯一的区别就是菱形继承时的查找顺序
一个类有多个父类 多个父类拥有一个共同父类
经典类 深度优先
新式类 先深度 遇到共同父类时 换另一条线 最后再查找共同父类 Object
接口
是一套协议规范
在python用一个类来定义接口
用来提前告诉子类们 应该如何实现
此时子类完全可以不遵守这个协议 就可以采用抽象类来进行限制
抽象类
抽象类 包含抽象方法的类
抽象方法 没有函数体的方法
其作用就是用于限制子类 必须实现某些方法
import abc
class A(metaclass=abc.ABCMeta)
@abc.abstracmethod
def test():
pass
抽象类无法直接实例化对象
python 一般不会强行限制你 所以 推荐使用鸭子类型
如果一个对象长得像鸭子 ,行为像鸭子 那就把它当成鸭子来看待
具体代码表现: 不用关心对象的类型 只要对象具备相同的行为和特征即可
组合:
一个对象把另一个对象作为属性
是为了复用代码
这是 什么有什么的关系 学生有电脑
封装:
指的是 限制外部对内部属性和方法的访问权限
公开的
谁都能访问 默认就是公开的
私有的
只有当前类本身可以访问
对外部隐藏内部实现细节,并提供使用接口
如何封装 在名称前添加__
被封装的呢内容外界无法直接访问 ,我们可以提供访问的接口
定义访问器 和 设置器 本质就是一个方法 通过方法来访问内部封装的内容
封装属性 提高安全性
封装方法 隔离复杂度
使用property 来将一个方法伪装成一个普通属性 可以用点直接访问
1.访问私有属性和普通属性方法一致
2.可以实现计算属性 (这个属性的值是通过计算得来可能会变化)
setter
用修改属性的值
deleter
删除某个属性
多态:
是一种特性 或一种状态
多个不同对象拥有相同的方法
1.接口
2.抽象类
3.鸭子类型(掌柜推荐)
好处是:
提高灵活性
以不变应万变
只需要掌握一套使用方法就可以使用多种不同对象
扩展性
提前写好了一套使用对象的代码 后续可以传入任何新类型的对象 只要它们长得像就行
__str__
在将对象转为字符串时自动触发执行 要求必须返回字符串
用来自定义对象的打印内容
__del__
析构函数 把对象拆干净
在对象删除前自动触发 ,用来做一些清理操作 ,例如对象可能打开了文件等等
反射
通过字符串来操作对象的属性
增
setattr
删
deleattr
改
setattr
查
hasattr 判断是否存在
getattr 获取属性的值
当你的代码以及提前写好了 而对象时后续传入的 那就需要用反射 来判断或获取属性 从而使用
在框架中到处都有反射
因为框架就是 先写好代码 后续再创建类和对象
动态导入:
静态 直接代码写死 import xxx.xx
动态 在任何位置 任何时候 都可以通过指定字符串类型的模块名称来导入模块