本节大纲：
一：在python中，有两种编程思想。1：函数式编程。2：oop。无论是函数式编程还是oop都是相辅相成。并不是说oop比函数式编程就好。各有各的优缺点。
在其他语言中java等只能以面向对象进行编程。
函数放在类中叫做方法。
只有对象才能调用类中的方法，也就是说需要创建该类的对象然后调用该类的方法。
而函数调用直接进行调用。
类需要创建对象，通过对象调用执行类中的方法。而函数可以直接进行调用，无需创建对象。
1：创建对象：和函数式调用雷同:类名()
obj=coo()
2:通过对象执行类中的方法.对象和属性用圆句点（.）进行连接。
obj.co()
二：定义类的语法：
a：class 类名：
def 方法名(self,x)
passs
关键字：class ,然后跟着类名。任何函数在类中都叫方法。方法的第一个参数必须是self。在构造对象的时候，会自动把对象名字传给self。类中的方法只能是对象来调用。
b：对象创建：
对象名=类名()
c：通过对象来执行类中的方法。
三：类和对象的关系
在创建对象的时候，在对象的内部有一个类对象指针指向自己的类。当对象执行check()方法的时候，根据类指针找到自己的类sql中的方法check进行执行。并把对象obj当做实参传给方法check的self形参。
并不是对象有该方法。
四：在什么情况下使用面向对象？
需求：对数据库的增删改查操作
a：函数式编程
#!/usr/bin/env python
def check(host,user,pwd,sql):
pass
def add(host,user,pwd,sql):
pass
def delete(host,user,pwd,sql):
pass
def update(host,user,pwd,sql):
pass
check('1.1.1.1','evil','','....')
add('1.1.1.1','evil','','....')
delete('1.1.1.1','evil','','....')
update('1.1.1.1','evil','','....')
没调用都需要传入，host、user、pwd、sql参数。如果操作数据库的动作较多，会反复传入多次。
面向对象编程：
class sql:
def check(self,sql):
print(self.host)
print(self.user)
print(self.password)
def crate(self,sql):
pass
def update(self,sql):
pass
def delete(self,sql):
pass obj=sql()
obj.host='1,1,1,1'
obj.user='evil'
obj.password=''
obj.check("select * from A")
,,,
evil
当我们执行相关操作的时候，我们只需要把数据封装到对象里，在调用类的方法的时候，自动获取对象的属性值，即可连接到数据库。而不需要每次都需要把账号、主机、密码都传入方法中进行操作。
什么时候用面向对象呢？
当某一些函数中有相同的参数的时候，可以用面向对象的封装特性，将参数值一次性的封装到对象，之后执行该对象的类的方法的时候不需要每次传入对应的参数。每次执行类的方法的时候，只需要从对象中取值即可。
五：self参数。
self 是python自动传值的形式参数。
当对象调用类的方法的时候，会自动把对象的赋值给self形式参数。
当obj调用类的方法check时候，self会自动赋值为obj，当obj1调用类sql的方法check时候，self会自动赋值obj1。
也就是说可以通过创建不通的对象来实现连接不通的数据库。
六：构造方法__init__
当执行类名()时候会自动执行类中的方法：__init__方法。
class sql:
def __init__(self):
print('__init__')
def check(self,sql):
print(self.host)
print(self.user)
print(self.password)
def crate(self,sql):
pass
def update(self,sql):
pass
def delete(self,sql):
pass obj=sql()
__init__
也就是说当执行对象创建的时候，也就是执行sql()的时候，会自动执行__init__方法。
根据这个特性，我们以后将对象封装的数据，方法__init__方法中。
class sql:
def __init__(self,a,b,c):
self.host=a
self.user=b
self.password=c
def check(self,sql):
print(self.host)
print(self.user)
print(self.password)
def crate(self,sql):
pass
def update(self,sql):
pass
def delete(self,sql):
pass obj=sql('1.1.1.1','evil','')
obj.check('selec.....') 1.1.1.1
evil
通过对象创建的时候，对__init__方法的参数进行实参的传入。
__init__方法叫做构造方法。构造对象的方法。
七：调用顺序
函数调用的时候，需要先声明函数，才能进行调用，而在类中，没有这个上下顺序，可以在方法声明前进行调用。
class sql:
def __init__(self,a,b,c,d):
self.host=a
self.user=b
self.password=c
self.check(d)
def check(self,sql):
print(self.host)
print(self.user)
print(self.password)
print(sql)
def crate(self,sql):
pass
def update(self,sql):
pass
def delete(self,sql):
pass obj=sql('1.1.1.1','evil','','check')
1.1.1.1
evil check
其中self.check(d)相当于obj.check('check')只不过是在构造方法执行的时候调用这个函数。
八：封装
class game_life:
def __init__(self,name,age,fight):
self.name=name
self.age=age
self.fight=fight
def battle_row(self):
self.fight=self.fight-
def study(self):
self.fight=self.fight+
def person_game(self):
self.fight=self.fight- obj=game_life('苍井井','',)
obj.battle_row()
print(obj.fight)
也就说 可以通过类的方法对类的对象的值进行修改。
面向对象三大特性：封装、继承、多太。
封装：将数据通过__init__方法封装到对象中。供方法进行调用和操作。
九：封装的对象可以数据，也可以是对象，可以任意东西。
class a:
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(self.name)
class b:
def __init__(self,name,obj):
self.name=name
self.obj=obj obj_a=a('evil',)
obj_b=b('tom',obj_a)
print(obj_b.obj.name)
print(obj_b.obj.age)
evil
也就是对象ojb封装的是name和对象obj_a.也就是说封装可以是数据，也可以是对象，也可以是任意事物。
class a:
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(self.name)
class b:
def __init__(self,name,obj):
self.name=name
self.obj=obj
class c:
def __init__(self,name,a):
self.name=name
self.a=a obj_a=a('evil',)
obj_b=b('tom',obj_a)
obj_c=c('jack',obj_b)
print(obj_c.a.obj.name)
obj_c.a.obj.show() evil
evil
res=obj_c.a.obj.show()
print(res)
注意show方法没有返回值，所以res值是None.
也就是通过obj_c怎么访问obj_a.show()或者obj_a.name?
如上图所示obj_c.a是obj_b对象，而obj_b.obj对象是obj_a对象，obj_a.name obj_a.show()是我们想要的结果。
所以：obj_c.a.obj.name obj_c.a.obj.show()
十：继承
在其他语言里java里只有单继承，而在python 中可以有多继承。语法：
class a:
def show(self):
print('show')
class b(a):
def co(self):
print('co')
obj=b()
obj.show()
show
也就是在类名后面加个(继承类的类名)即可。也就是说a相当于与b是父类，b相对于a是子类，或者说a是基类，b是派生类。注意说法，各自对应。谁是父类，谁是子类只是相对而言。子类可以继承父类的方法。父类不可以继承子类的方法。
如上，当对象obj调用方法show的时候，优先看自己类中是否有该方法，如果有就执行，不去父类找该方法。如果该方法没有的话去找他的父类是否有该方法。如果有就执行。
class a:
def show(self):
print('show')
class b(a):
def co(self):
print('co')
def show(self):
print('b')
obj=b()
obj.show()
b
继承的本质：子类没有的方法，方法在父类里，在对象调用该方法的时候，相当于父类的方法拿到子类的中。如下：
class a:
def __init__(self,name):
self.name=name
def show(self):
print(self.name)
class b(a):
def __init__(self,name):
self.name=name
def co(self):
print('co')
obj=b('tom')
obj1=a('evil')
obj.show()
tom
也就是说子类对象obj在调用父类show方法的时候，传入的self.name是子类的self.name。也就是说相当于把父类的方法show拿到子类中。
如上所示：对象obj在执行方法show时候优先去子类b中找show方法，如果子类没有show方法的话，去父类的a中找show方法，并执行show方法，show方法
相当于拿到子类b中，因为子类b在构造对象obj的时候，已经封装数据self.name=name，所以获取的是子类的b的对象数据，也就是tom。而不是父类a的self.name属性。
class a:
def s1(self):
print(a)
def s2(self):
self.s1()
class b(a):
def s1(self):
print('b')
def s3(self):
self.s2() obj=b()
obj.s3()
b
继承优先级：如果子类继承父类，对象在调用方法的时候，优先子类中找，如果有该方法执行该方法，如果没有在去父类找该方法。本质是：把父类的该方法拿到子类中，进行调用执行。
继承优先执行子类的中方法，如果子类中有该方法执行子类方法。
另一个思路：在执行self.xx的时候需要注意self是指执行对象，需要去执行对象的类型中去找，如果没有，再去父类找。
十一：多继承(python3中)
class a:
def f2(self):
print('class a')
class b:
def f2(self):
print('class b')
class c(a,b):
def f3(self):
pass
obj=c()
obj.f2()
class a
多继承的时候，优先从左有到右。如上classc(a,b)子类c中没有方法f2，在去父类a,b中找，优先顺序 a 然后是b。从左到右顺序。
没有父类交叉的情况：
class s1:
def f1(self):
print('s1')
class s2(s1):
def f2(self):
print('s2')
class s3:
def f1(self):
print('s3')
class s4(s2,s3):
def f2(self):
print('s4')
obj=s4()
obj.f1()
s1
当有纵向和横向的多继承时候，顺序：首先按继承顺序，从左到右优先级，先从对象的类中找，如果没有按对象类型的父类（从左右）中找，如果没有，去他的父类的父类中找，如果最后
没有的话，在找下一个对象的类父类平行的中父类中找，按照之前如果没有在去父类的父类找。。 如果没有在回到对象的类的平行父类中。。
父类有交叉的情况：
class s_1:
def f2(self):
print('s_1')
class s0(s_1):
def f2(self):
print('s0')
class s1(s_1):
def f1(self):
print('s1')
class s2(s1):
def f1(self):
print('s2')
class s3(s0):
def f1(self):
print('s3')
class s4(s2,s3):
def f1(self):
print('s4')
obj=s4()
obj.f2() s0
优先没交集的父类，当这个2个都遍历照完之后在找交集部分，在去平行的父类找也就是第7步。代码如下：
class s_1:
def f1(self):
print('s_1')
class s0(s_1):
def f1(self):
print('s0')
class s1(s_1):
def f1(self):
print('s1')
class s2(s1):
def f1(self):
print('s2')
class s3(s0):
def f1(self):
print('s3')
class s5:
def f2(self):
print('s5')
class s4(s2,s3,s5):
def f1(self):
print('s4')
obj=s4()
obj.f2()
s5
关于__init__构造方法：当对象创建的时候，会自动去自己类中找__init__构造方法，如果没有去父类找。如果有的话执行__init__方法。如果都没有就不执行该方法。
class s1:
def __init__(self,name):
self.name=name
def show(self):
pass
class s2(s1):
def look(self):
pass obj=s2('evil')
print(obj.name)
evil
查找顺序和 多继承顺序是一样的。
模块：configparser 针对特殊配置文件进行操作。其本事是对文件的open()操作。
如下：
[section1] # 节点
k1 = v1 # 值
k2:v2 # 值 [section2] # 节点
k1 = v1 # 值
操作：获取所有节点
import configparser con=configparser.ConfigParser()
con.read('1.txt',encoding='utf-8')
res=con.sections()
print(res)
['section1', 'section2']
获取指定节点下的key和值
import configparser con=configparser.ConfigParser()
con.read('1.txt',encoding='utf-8')
res=con.items('section1')
print(res)
[('k1', 'v1'), ('k2', 'v2')]
获取指定节点下的键值
import configparser con=configparser.ConfigParser()
con.read('1.txt',encoding='utf-8')
res=con.options('section1')
print(res)
['k1', 'k2']
获取指定节点指定值
import configparser con=configparser.ConfigParser()
con.read('1.txt',encoding='utf-8')
res=con.get('section1','k1')
print(res)
v1
import configparser con=configparser.ConfigParser()
con.read('1.txt',encoding='utf-8')
has_sec = con.has_section('section1')
print(has_sec) # 添加节点
con.add_section("sec_1")
con.write(open('1.txt', 'w')) # 删除节点
con.remove_section("sec_1")
con.write(open('1.txt', 'w'))
XML模块
xml是实现不同语言或程序之间进行数据交换的协议
格式如下：
<data>
<country name="Liechtenstein">
<rank updated="yes"></rank>
<year></year>
<gdppc></gdppc>
<neighbor direction="E" name="Austria" />
<neighbor direction="W" name="Switzerland" />
</country>
<country name="Singapore">
<rank updated="yes"></rank>
<year></year>
<gdppc></gdppc>
<neighbor direction="N" name="Malaysia" />
</country>
<country name="Panama">
<rank updated="yes"></rank>
<year></year>
<gdppc></gdppc>
<neighbor direction="W" name="Costa Rica" />
<neighbor direction="E" name="Colombia" />
</country>
</data>
解析xml文件
from xml.etree import ElementTree as E
str_xml = open('1.xml', 'r').read()# 打开文件，读取包含xml文件内容
root = E.XML(str_xml)# 将字符串解析成xml特殊对象，root代指xml文件的根节点
from xml.etree import ElementTree as E
tree = E.parse("1.xml")# 直接解析1.xml文件
root = tree.getroot()# 获取xml文件的根节点
遍历xml文件的所有内容
from xml.etree import ElementTree as E #第一种解析
"""
str_xml = open('1.xml', 'r').read()#打开文件读取1.xml文件
root = ET.XML(str_xml)#将字符串解析成xml特殊对象，root代指xml的根节点。
"""
# 第二种解析
# 直接解析xml文件
tree = E.parse("1.xml")
root = tree.getroot()#获取xml文件的根节点
# operation
print(root.tag)#最外层标签 for child in root:# 遍历1.xml的第二层
print(child.tag, child.attrib) # 第二层节点的标签名称和标签属性
for i in child:# 遍历XML文档的第三层
print(i.tag,i.text)# 第二层节点的标签名称和内容
因为修改的节点内容是修改在内存中的内容，需要把内存中内容写入文件中。
from xml.etree import ElementTree as E # 直接解析xml文件
tree = E.parse("1.xml") # 获取xml文件的根节点
root = tree.getroot() #operation # 顶层标签
print(root.tag)
for i in root.iter('year'):# 循环year节点 new_year = int(i.text) + # 将year节点中的内容自增一
i.text = str(new_year) i.set('name', 'alex') # 设置属性
i.set('age', '')
del i.attrib['name']# 删除属性 #保存到文件中
tree.write("3.xml", encoding='utf-8')
删除节点操作：
from xml.etree import ElementTree as E # 解析文件方式 # 直接解析xml文件
tree = E.parse("1.xml") root = tree.getroot()# 获取xml文件的根节点 #operation print(root.tag)#输出顶层标签
for country in root.findall('country'):# 遍历data下的所有country节点
rank = int(country.find('rank').text)# 获取每一个country节点下rank节点的内容
if rank > : root.remove(country)# 删除指定country节点
tree.write("2.xml", encoding='utf-8')# 保存文件