python 3全栈开发-面向对象之绑定方法(classmethod与staticmethod的区别)、多态、封装的特性property

一、面向对象绑定方法

一、类中定义的函数分成两大类

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是计算而来的,但很明显它听起来像是一个属性而非方法,如果我们将其做成一个属性,更便于理解)

成人的BMI数值:
过轻:低于18.5
正常:18.5-23.9
过重:24-27
肥胖:28-32
非常肥胖, 高于32
  体质指数(BMI)=体重(kg)÷身高^2(m)
  EX:70kg÷(1.75×1.75)=22.86
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)
上一篇:把安卓源代码中的system app独立出来,像开发普通app那样开发


下一篇:mongo分片集群部署