day27 ( configparser , subprocess , xlrd , xlwt , xml , 面向对象 )


一 , 配置文件解析:

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)

 

二 ,  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

"""
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获取硬件信息

 

4 ,  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")

 

5 , 面向对象

 
 
'''
面向对象是什么?
是一种编程思想,指导你如何更好的编写代码
关注点在对象二字
具体存在的,拥有某些特征和行为
类,具备相同特征和行为的集合体,是对象的抽象概念
在程序中先有类后有对象,在现实中先有对象后有类

面向过程和面向对象的对比:

面向过程关注的是过程二字,是实现任务的具体过程,即先干什么后干什么,一种机械式思维,是一个具体的操作者

面向对象关注的是对象二字,即实现某个任务需要什么对象,就调用哪个对象去实现就好了,不用关系实现细节,从一个操作者变成了指挥者

优点:
提高了扩展性,复用性,降低了耦合度,易维护
缺点:
编程的复杂度变高了,容易出现过度设计,无法准确预支执行结果

使用场景:
当对于扩展性在要求较高时,较大的程序应该优先考虑面向对象
面向过程一时爽,重构火葬场

面向过程
优点:
将复杂问题简单化,流程化
缺点:
扩展性差,维护成本高

绑定方法:
对象绑定方法:
一个类中的方法默认是绑定给对象的
对象调用时会自动传入对象本身
类绑定方法:
@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,"张三!")

'''
继承:
在程序中是一种关系,是类与类之间的关系,是一种什么是什么的关系
子类可以直接使用父类提供的内容,目的就是减少代码允余,提高复用性

继承的使用方式:
使用方法 1:
先抽象
抽取一系列类中相同的特征和行为,形成新的类
在继承
例如老师和学生,可以抽取一个Person类,将相同的姓名 年龄 性别 进行抽取

使用方法2:
继承一个已经存在的类,扩展新功能或修改原有的功能
但是不要忘记 supser() 调用原来的方法

派生
子类拥有父类不同的内容
覆盖(重写)
子类出现了与父类名称完全一致的内容 ,父类的将被覆盖

子类访问父类的内容
super().__init__(name,age,gender)

python 支持多继承
新式类:直接或间接继承了object的类, py3都是新式类
经典类:不是object的子类,仅在py2中存在

多继承引发的问题:
多个父类中出现了相同名字时,到底用哪个?

新式类可以通过类名.mro()来查看顺序
如果是经典类,是深度优先
唯一的区别就是菱形继承时的查找顺序
一个类有多个父类,多个父类拥有共同父类
经典类 深度优先
新式类 先深度,遇到共同父类时,换另一条线,最后在查找共同的父类

接口:
是一套协议规范
在python用一个类来定义接口,用来提前告诉子类们,应该如何实现
此时子类完全可以不遵守这个协议,就可以采取抽象类来进行限制

抽象类
抽象类 包含抽象方法的类
抽象方法 没有函数体的方法
其作用就是用于限制子类,必须实现某些方法

import abc
class A(metaclass=abc.ABCMeta)
@abc.abstractmethod
def test():
pass

抽象类无法直接实例化对象,实现了抽象类方法的子类才能被实例化

python 一般不会强行限制你,所以,推荐使用鸭子类型
如果一个对象长的像鸭子,行为像鸭子,那就把它当成鸭子
具体代码表现:不用关系对象的类型,只要对象具备相同的行为和特征即可

组合:
一个对象把另一个对象作为属性,是为了复用代码
是什么拥有什么的关系,如:学生有手机

封装:
指的是限制外部对内部的属性和方法的访问权限
公开的:
谁都能访问,默认就是公开的
私有的:
只有在当前类本身才可以被访问

对外部隐藏内部的实现细节,提供使用接口

如何封装,在名称前添加__

被封装的内容外界无法直接方法,我们可以提供访问的接口
定义访问器(get)和设置器(set) 本质就是一个方法,通过方法来访问内部封装的内容

封装属性: 提供安全性
封装方法 : 隔离复杂度

使用property 来将一个方法伪装成一个普通属性,可以直接用点访问
1,访问私有属性和普通属性方法一致
2,可以实现计算属性(这个属性的值是通过计算得来的,可能会变化)

setter :
用来修改属性的值
deleter :
删除某个属性

多态:
是一种特性,或一种状态,多个不同对象拥有相同的方法
实现方式:
1,接口
2,抽象类
3,鸭子类型

多态好处:
提高了灵活性:
以不变应万变
只需掌握一套使用方法就可以使用多种不同对象
提高了扩展性:
提前写好了一套使用对象的代码,后续可以传入任何新类型的对象,只要他们长的像就都可以使用

__str__
在将对象转为字符串时自动触发执行 要求返回字符串
用来自定义对象的打印内容

__del__
析构函数 把对象拆干净
在对象删除前自动触发,用来做一些清理操作,例如:对象打开了文件等

反射:
通过字符串来操作对象的属性
增:
setattr
删:
deleattr
改:
setattr
查:
hashattr 判断是否存在
getattr 获取属性的值

当你的代码以及提前写好了,而对象时后续传入的,那就需要用反射,来判断或获取属性,从而使用
在框架中到处都有反射:
因为框架就是 先写好代码,后续在创建类和对象

动态导入:
静态:直接代码写死 import xxx.xxx
动态:在任何位置,任何时候,都可以通过指定字符串类型的模块名称来导入模块

'''''
# class A:
#     name = "a"
#
# class B(A):
#     age = 20
#
# b = B()
# b.name
# b.age


class Person:
    school = "oldgirl"
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def say_hi(self):
        print(self.name)


class Teacher(Person):

    def teach(self):
        print("教书中....")

class Student(Person):

    def __init__(self,name,age,gender,number):
        super().__init__(name,age,gender) # 会根据mro继承列表查找属性
        # Person.__init__(self,name,age,gender)
        self.number = number



    def study(self):
        print(self.school)
        print("上课中...")

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com