一、面向对象编程
面向对象--Object Oriented Programming，简称oop，是一种程序设计思想。把一些公用的函数封装到一个类里面。
二、类
属性：属性就是类里面的一个变量，有类变量和实例变量，类变量是类在定义的时候就有的，实例变量是在实例化的时候才产生的变量。
方法：方法就是类的功能，也就是定义在类里面的函数。
构造函数：类被实例化的时候，它会自动的执行构造函数，做的某些初始化操作。
析构函数：析构函数是实例在销毁的时候做的一些操作。
定义类：定义类使用class关键字，类名一般我们开发的时候首字母要大写。python中有经典类和新式类。
继承：父类有的功能、变量子类全有。如果定义的类，有很多重复功能的，那就可以把这些重复的类，定义成父类
多态：python里面是不直接支持多态的，可以通过别的方法来实现多态。
私有方法、私有属性：什么是私有，私有就是只有在类里面可以访问，实例化之后不可以访问和调用，有私有方法和私有属性。私有就把变量名或者函数名前面加上"__"两个下划线，其实就是通过私有来实现封装的。
类方法：不需要实例化就能直接用的,它可以使用类变量和类方法。类方法，也不需要实例化，直接就能用。它静态方法高级一点，它可以使用类变量和类方法。
静态方法：不需要实例化就能直接用的，其实和类没有什么关系，就是一个普通的函数，写在了类里面而已,也用不了self的那些东西，也调用不类里面的其他函数。
示例：
类定义
class Person(object):#定义类，这个是新式类
nationality = 'China' #类属性
def __init__(self,name,sex): #构造函数
self.name = name #实例属性
self.sex =sex
def __del__(self):#析构函数
print('这个是析构函数')
def info():#方法
print('name is %s sex is %s '%(self.name,self.sex))
class Person1:#定义类，这个是经典类
nationality = 'China' #类属性
def __init__(self,name,sex): #构造函数
self.name = name #实例属性
self.sex =sex
def info():#方法
print('name is %s sex is %s '%(self.name,self.sex))
niuniu = Person('牛牛','男') #实例化，因为在上面的构造函数里面指定了必须传name和sex，所以在实例化的时候要把name和sex传进去
niuniu.info()#调用实例方法
继承
class F(object):
'''
这个是父类
'''
def __init__(self,name,sex):
self.name = name
self.sex = sex
def info():#方法
print('name is %s sex is %s '%(self.name,self.sex))
class S(F):#继承F这个类
pass
s1 = S('牛牛','男')#实例化子类
s1.info()#因为继承父类，所以父类的方法他都有
那如果在父类里面有一个方法，子类里面也有的话，但是子类想重写一下父类的方法，增加新功能下面这么写：
class test():
def __init__(self,name):
self.name = name
class test1(test):
def __init__(self,name,age):
# test.__init__(self,name)#修改父类的方法，这个是经典类里面的写法
super(test1,self).__init__(name)#和上面的效果一样，这个是新式类里面的写法
self.name = name
self.age = age
test1('name','age')
多继承，上面写的都是单继承的，
python里面还支持多继承，多继承就是继承多个父类，在python3中多继承都是广度优先的，在python2中有点不同，经典类是深度优先，新式类是广度优先。
class A:
def say(self):
print('A')
class B(A):
# pass
def say(self):
print('B')
class C(A):
pass
# def say(self):
# print('c')
class D(C,B):
pass
s=D()
s.say()
私有方法、私有属性
class Dog(object):
__type = '狗'#私有属性
def cry(self):
self.__test()#调用私有方法
print('私有属性%s'%self.__type)
print('狗 [%s] 汪汪汪'%self.name)
def __test(self):#私有方法
self.name = 'test'#
d = D()
d.cry()#正常可以调用
d.__type#报错，因为是私有属性，在外面不能访问
d.__test()#报错，因为是私有方法，在外面不能访问
静态方法和类方法
class Stu(object):
country = 'china'#类变量
def __init__(self,name):
self.name = name
@staticmethod
#静态方法，和类本身没有什么关系了，就相当于在类里面定义了一个方法而已
def say():
print('xxx')
@classmethod
#静态方法，和类方法不同的是，它可以使用类变量，必须要传一个值，代表的就是这个类
def hello(cls):
print(cls.country)
def hi(self):
#这个是实例方法
print(self.name)
t = Stu('name')
Stu.hello()
Stu.say()
t.hi()
t.say()
t.hello()
重写父类
import redis
class Coon(object):
#基类
def __init__(self,host,passwd,port):
self.host= host
self.passwd=passwd
self.port= port
class CoonMySql(Coon):
def __init__(self,host,passwd,port,username,db,charset='utf8'):
#Coon.__init__(self,host,passwd,port) #z在调用父类的构造方法，咱们自己手动调用父类的方法
super(CoonMySql,self).__init__(host,passwd,port) #super会自动找到父类，然后调用下面的方法
self.username=username
self.db=db
self.charset=charset
def coon_mysql(self):
print(self.host,self.host)
class CoonRedis(Coon):
def conn(self,host,passwd,port):
Coon.conn(self, host, passwd, port)
redis.Redis(host=self.host,password=self.passwd,port=self.port)