面向对象编程-中
面向对象三大特征：封装、继承、多态。
封装：把内容封装起来便于后面的使用。对于封装来讲，就是使用__init__方法将内容封装道对象中，然后通过对象直接或者self获取被封装的内容。
继承：子继承父的属性和方法。
多态：所谓多态就是定义时的类型和运行时的类型不一样，同一种行为对于不同的子类对象有不同的行为表现。python不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，"鸭子类型"。
鸭子类型：在程序设计中，鸭子类型是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。
鸭子测试：当看到一只鸟走起来像鸭子、游泳像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。
在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。
1.析构函数
析构方法：当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__()方法，也成为析构方法。
一般来讲程序执行结束自动调用此方法。
python
#析构方法
class Animal:
def __init__(self,name):
self.name=name
print('init方法调用，初始化%s对象'%(self.name))
pass
def __del__(self):
print('del方法调用，释放%s内存空间'%(self.name))
pass
pass
cat=Animal('猫')
print('=================')
dog=Animal('柯基')
#由此可看，是当函数彻底执行结束后才释放所有内存空间
除此之外，对象被删除的时候也会调用析构方法。
python
#析构方法
class Animal:
def __init__(self,name):
self.name=name
print('init方法调用，初始化%s对象'%(self.name))
pass
def __del__(self):
print('del方法调用，释放%s内存空间'%(self.name))
pass
pass
cat=Animal('猫')
del cat #手动删除对象，执行__del__方法
print('=================')
dog=Animal('柯基')
析构方法主要是用于释放空间，释放后对象就不能再使用。
总结：
当整个程序脚本执行完毕后会自动调用__del__方法
当对象被手动销毁时也会自动调用__del__方法
析构函数一般用于资源回收，利用__del__方法销毁对象回收内存等资源
2.继承
2.1 单继承
python
#单继承
#父类：
class Animal:
def eat(self):
'''
父类方法
:return:
'''
print('吃')
pass
def drink(self):
'''
父类方法
:return:
'''
print('喝')
pass
pass
#子类
class Dog(Animal): #继承Animal
def wwj(self):
'''
子类独有的方法
:return:
'''
print('小狗汪汪叫')
pass
class Cat(Animal):
def mmj(self):
'''
子类独有的方法
:return:
'''
print('小猫喵喵叫')
pass
pass
d1=Dog()
d1.eat()
c1=Cat()
c1.drink()
对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法，极大提高效率，精简代码，便于扩展。
单继承的语法：
class 子类名(父类名):
.......
2.2 多继承
子类可以继承多个父类，同时拥有多个父类的公共方法。
python
#多继承
#父类1
class God:
def fly(self):
print('神都会飞')
pass
pass
#父类2
class Monkey:
def eat(self):
print('猴子都吃桃子')
pass
pass
#子类
class Swk(God,Monkey): #多继承
def chan(self):
print('孙悟空会七十二变')
pass
pass
s=Swk()
s.chan()
s.fly()
s.eat()
当多个父类中存在相同的方法时，一层层向上找，就近原则使用。
python
class D(object):
def eat(self):
print('D.eat')
pass
pass
class C(D):
def eat(self):
print('C.eat')
pass
pass
class B(D):
pass
class A(B,C):
pass
a=A()
a.eat()
print(A.__mro__) #可以显示类的依次继承关系
2.3 继承的传递
孙-子-父
python
class Grandfather:
def eat(self):
print('爷爷的吃')
pass
pass
class Father(Grandfather):
pass
class Son(Father):
pass
s=Son()
print(Son.__mro__)
s.eat() #此方法是从父类的父类继承过来的
#在类的传递过程中，我们把父类称为基类，子类称为派生类，父类的属性喝方法可以一级一级的传到子类，多少级都可以
3.重写父类方法
所谓重写就是在子类中有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法，实际上也就是上述的"就近原则"，这种重写的方法中父类子类的变量什么的都是不互通的。
但如果一味的重写会使父类继承失去意义，因此如果在子类中重写时可以调用父类方法，提高代码效率。
4.调用父类方法
python
class Dog:
def __init__(self,name,color):
self.name=name
self.color=color
pass
def bark(self):
print('叫')
pass
pass
class keji(Dog):
def __init__(self,name,color):
Dog.__init__(self,name,color) #法一：手动调用调用父类的方法，执行完毕就可以具备name,color这两个实例属性了
super().__init__(name,color) #法二：也可以这样调用super是自动找到父类进而调用方法，如果有多个父类会逐一的找直到找到为止
self.height=20 #如果想要除了父类中的属性之外的属性可以声明
pass
def bark(self):
super().bark()
print('柯基叫')
print(self.name)
pass
def __str__(self):
return '{}的颜色是{},它的身高是{}'.format(self.name,self.color,self.height)
pass
kj=keji('柯基','黄')
kj.bark()
print(kj )
注：
super()自动调用和手动调用写一个就行
5.多态
要想实现多态必须遵守两个前提：
1.继承：多态必须发生在父类和子类之间
2.重写：子类必须要重写父类的方法
python
#多态
class Animal:
def speak(self):
print('我是')
pass
class Duck(Animal):
pass
duck=Duck()
duck.speak()
python
#多态
class Animal:
def speak(self):
print('我是')
pass
class Duck(Animal):
def speak(self):
print('我是一个鸭子')
pass
duck=Duck()
duck.speak()
以上就是一种多态的体现，同样是duck.speak，输出两个不一样的结果。
法一：
python
#多态
class Animal:
def speak(self):
print('我是')
pass
class Duck(Animal):
def speak(self):
print('我是一个鸭子')
pass
duck=Duck()
duck.speak()
class Dog(Animal):
def speak(self):
print('我是一只小狗')
pass
pass
dog=Dog()
dog.speak()法二：
python
#多态
class Animal:
def speak(self):
print('我是')
pass
class Duck(Animal):
def speak(self):
print('我是一个鸭子')
pass
class Dog(Animal):
def speak(self):
print('我是一只小狗')
pass
pass
def commonInvoke(obj):
'''
统一调用的方法
:param obj:对象的实例
:return:
'''
obj.speak()
pass
listObj=[Duck(),Dog()]
for i in listObj:
'''
循环调用函数
'''
commonInvoke(i)
#用一个函数调用
以上是多态的第二种体现
多态的优点：
增加程序的灵活性
增加程序的扩展性
6.类属性和实例属性
类属性是类对象所拥有的属性，它被所有类对象的实例对象共有，类对象和实例对象可以访问。
实例属性是实例对象所拥有的属性，只能通过实例对象访问
python
#类属性
class Student:
name='黎明' #类属性
def __init__(self,age):
self.age=age #实例属性
pass
pass
lm=Student(18)
print(lm.name) #通过实例对象访问类属性
print(lm.age)
print('------------')
print(Student.name) #通过类对象访问name
print(Student.age) #报错是因为age归实例对象所有，不属于类对象
#只有类属性可以被类对象和实例对象共同访问
#实例属性只能由实例对象访问
所有的实例对象访问的类属性是一个值，实例属性不同。
实例对象对于类属性只有使用的权力，没有修改的权力。
python
#类属性
class Student:
name='黎明' #类属性
def __init__(self,age):
self.age=age #实例属性
pass
pass
lm=Student(18)
print(lm.name) #通过实例对象访问类属性
lm.name='修改' #重新声明一个值
print(lm.age)
print(lm.name) #重新声明后改变了自己
print('------------')
xh=Student(22)
print(xh.name) #重新声明完后并没有改变
print('----------------')
print(Student.name) #通过类对象访问name
python
#类属性
class Student:
name='黎明' #类属性
def __init__(self,age):
self.age=age #实例属性
pass
pass
Student.name='change' #这样可以彻底改变类属性的值
lm=Student(18)
print(lm.name) #通过实例对象访问类属性
print(lm.age)
print(lm.name) #重新声明后改变了自己
print('------------')
xh=Student(22)
print(xh.name) #重新声明完后并没有改变
print('----------------')
print(Student.name) #通过类对象访问name
7. 类方法和静态方法
7.1 类方法
类方法：类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数，类方法可以通过类对象、实例对象调用。
python
#类方法
class People:
country='china'
@classmethod
def get_country(cls):
return cls.country #访问类属性
pass
@classmethod
def change_country(cls,data):
cls.country=data #在类方法中修改类属性的值
pass
pass
print(People.get_country()) #通过类对象去引用
p=People()
print(p.get_country())
p.change_country('england')
print(p.get_country())
7.2 静态方法
类对象所拥有的方法，需要用@staticmethod标识静态方法，静态方法不需要任何参数。
python
#类方法
class People:
country='china'
@classmethod
def get_country(cls):
return cls.country #访问类属性
pass
@classmethod
def change_country(cls,data):
cls.country=data #在类方法中修改类属性的值
pass
@staticmethod
def getData():
return People.country
pass
pass
print(People.getData())
p=People()
print(p.getData()) #一般情况下，我们不会通过实例对象访问静态方法
#静态方法的逻辑实现和类、实例对象没什么交互，主要用来存放逻辑性代码，一般不会涉及到类中方法和属性的操作。数据资源能够得到充分利用
# 返回当前的系统时间：
import time
class Time:
@staticmethod
def showTime():
return time.strftime('%H:%M:%S',time.localtime())
pass
print(Time.showTime())7.3 区别
1.类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法，用装饰器@classmethod修饰
2.实例方法的第一个参数是实例对象self，通过self引用的可能是类属性，也有可能是实例属性，具体问题具体分析，不过存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。
3.静态方法中不需要额外定义参数，因此在静态方法中引用类属性的化必须通过类对象引用，必须用@staticmethod修饰。