一、面向对象绑定方法
一、类中定义的函数分成两大类
1、绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：
1. 绑定到类的方法：用classmethod装饰器装饰的方法。
为类量身定制
自动将类当作第一个参数传入（其实对象也可调用，但仍将类当作第一个参数传入）
2. 绑定到对象的方法：没有被任何装饰器装饰的方法。
为对象量身定制
自动将对象当作第一个参数传入（属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）
2：非绑定方法：
用staticmethod装饰器装饰的方法
1. 不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已
注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说
二、 绑定方法
绑定给类的方法（classmethod）
classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法
#setting.py 文件的内容NAME="duoduo"AGE=18
import settingsclass 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 settingsimport hashlibimport timeclass 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_area400#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码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 #调用内置模块abcclass Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstractmethod #当下面的子类，没有talk方法是，就会报错 def talk(self): passclass 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): passclass 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,ts.__len__()l.__len__()t.__len__()len(s)len(l)len(t)