一、面向对象绑定方法
一、类中定义的函数分成两大类
1、绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：
1. 绑定到类的方法：用classmethod装饰器装饰的方法。
为类量身定制
自动将类当作第一个参数传入（其实对象也可调用，但仍将类当作第一个参数传入）
2. 绑定到对象的方法：没有被任何装饰器装饰的方法。
为对象量身定制
自动将对象当作第一个参数传入（属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）
2：非绑定方法：
用staticmethod装饰器装饰的方法
1. 不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已
注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说
二、 绑定方法
绑定给类的方法（classmethod）
classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法
#setting.py 文件的内容
NAME="duoduo"
AGE=18
import settings class People:
def __init__(self,name,age):
self.name=name
self.age=age def tell(self):
print('%s：%s' %(self.name,self.age)) @classmethod #python3的内置函数是装饰器
def from_conf(cls): #这里的cls，是约定俗称一个类的名字跟self约定为对象是一样的
return cls(settings.NAME,settings.AGE) p4=People.from_conf() #这里我们发现不需要再传入类
p4.tell()
三 、非绑定方法
在类内部用staticmethod装饰的函数即非绑定方法，就是普通函数
statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果
import settings
import hashlib
import time class People:
def __init__(self,name,age):
self.uid=self.create_id()
self.name=name
self.age=age def tell(self):
print('%s: %s：%s' %(self.uid,self.name,self.age)) @staticmethod #跟classmethod一样都是内置函数也是装饰器
def create_id():
m=hashlib.md5()
m.update(str(time.clock()).encode('utf-8'))
return m.hexdigest() obj=People('duoduo',18)
print(obj.create_id()) #这里调用就很正常的调用没有自动传值一说
print(People.create_id())
二、封装的特性(property)
1、什么是特性property
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
例：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
class People:
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height
@property
def bmi(self):
return self.weight / (self.height * self.height)
duoduo=People('duoduo',70,1.70)
# 但很明显人的bmi值听起来更像一个名词而非动词
# print(duoduo.bmi()) # 未用装饰器前的调用
# 于是我们需要为bmi这个函数添加装饰器，将其伪装成一个数据属性
# duoduo.weight=65 #改变duoduo的weight
# print(duoduo.bmi) #22.49134948096886，调用duoduo.bmi本质就是触发函数bmi的执行，从而拿到其返回值
# print(duoduo.bmi)
2、为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
除此之外
class People:
def __init__(self,name):
self.__name=name @property
def name(self): #obj.name
print('您现在访问的是用户名。。。')
return self.__name @name.setter #obj.name='DUODUO'
def name(self,x):
# print('=================',x)
if type(x) is not str:
raise TypeError('名字必须是str类型，傻叉')
self.__name=x @name.deleter
def name(self):
# print('就不让你删')
del self.__name # obj=People('duoduo')
# print(obj.name)
# obj.name='DUODUO' #修改名字属性为DUODUO
# print(obj.name)
# del obj.name #删除名字属性
# obj.name #删除后，看报错
3 、封装与扩展性
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。
#类的设计者
class Room:
def __init__(self,name,owner,width,length,high):
self.name=name
self.owner=owner
self.__width=width
self.__length=length
self.__high=high
def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
return self.__width * self.__length #使用者
>>> r1=Room('卧室','duoduo',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area
400 #类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
def __init__(self,name,owner,width,length,high):
self.name=name
self.owner=owner
self.__width=width
self.__length=length
self.__high=high
def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,
#只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
return self.__width * self.__length * self.__high #对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()
8000
三、 多态
1、什么叫多态
多态指的是一类事物有多种形态
例子：动物有多种形态：人，狗，猪
import abc #调用内置模块abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
@abc.abstractmethod #当下面的子类，没有talk方法是，就会报错
def talk(self):
pass
class People(Animal): #动物的形态之一:人
def talk(self):
print('say hello')
class Dog(Animal): #动物的形态之二:狗
def talk(self):
print('say wangwang')
class Pig(Animal): #动物的形态之三:猪
def talk(self):
print('say aoao')
2、 多态性
1）什么是多态性
多态性是指在不考虑实例类型的情况下使用实例：
比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同
2）多态性分为静态多态性和动态多态性
静态多态性：如任何类型都可以用运算符+进行运算
动态多态性：如下
peo=People()
dog=Dog()
pig=Pig() #peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk() #更进一步,我们可以定义一个统一的接口来使用
def func(obj):
obj.talk()
3、为什么要用多态性（多态性的好处）
其实大家从上面多态性的例子可以看出，我们并没有增加什么新的知识，也就是说python本身就是支持多态性的，这么做的好处是什么呢？
1）增加了程序的灵活性
以不变应万变，不论对象千变万化，使用者都是同一种形式去调用
2）增加了程序额可扩展性
通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用
class Cat(Animal): #属于动物的另外一种形态：猫
def talk(self):
print('say miao') def func(animal): #对于使用者来说，自己的代码根本无需改动
animal.talk() cat1=Cat() #实例出一只猫
func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao #这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。
#使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
4、 鸭子类型
逗比时刻：
Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’
python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象
也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。
例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法
#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
def read(self):
pass def write(self):
pass class DiskFile:
def read(self):
pass
def write(self):
pass
例2：其实大家一直在享受着多态性带来的好处，比如Python的序列类型有多种形态：字符串，列表，元组，多态性体现如下
#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6)) #我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__() len(s)
len(l)
len(t)