威尼斯wns.9778官网活动_vnsc威尼斯城官网

热门关键词: 威尼斯wns.9778官网活动,vnsc威尼斯城官网
当前位置:威尼斯wns.9778官网活动 > 计算机教程 > 10 多态

10 多态

文章作者:计算机教程 上传时间:2019-05-10

5 属性查找与绑定方法

二、封装的特性(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             #删除后,看报错

11 封装

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

1、绑定方法(绑定给谁,谁来调用就自动将它本身当作第一个参数传入):

    1. 绑定到类的方法:用classmethod装饰器装饰的方法。

                  为类量身定制

                  自动将类当作第一个参数传入(其实对象也可调用,但仍将类当作第一个参数传入)

    2. 绑定到对象的方法:没有被任何装饰器装饰的方法。

                 为对象量身定制

      自动将对象当作第一个参数传入(属于类的函数,类可以调用,但是必须按照函数的规则来,没有自动传值那么一说)

2:非绑定方法:

  用staticmethod装饰器装饰的方法

        1. 不与类或对象绑定,类和对象都可以调用,但是没有自动传值那么一说。就是一个普通工具而已

    注意:与绑定到对象方法区分开,在类中直接定义的函数,没有被任何装饰器装饰的,都是绑定到对象的方法,可不是普通函数,对象调用该方法会自动传值,而staticmethod装饰的方法,不管谁来调用,都没有自动传值一说

3 面向过程与面向对象进一步比较

三 、非绑定方法

在类内部用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())

14 内置方法(中)之描述符

三、 多态

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')

面向对象学习目录

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 peo=People()
 2 dog=Dog()
 3 pig=Pig()
 4  
 5 #peo、dog、pig都是动物,只要是动物肯定有talk方法
 6 #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
 7 peo.talk()
 8 dog.talk()
 9 pig.talk()
10  
11 #更进一步,我们可以定义一个统一的接口来使用
12 def func(obj):
13     obj.talk()

所以,总结下抽象类与多态的关系:

  先由抽象类统一定义这些相似类的相似属性(包括数据属性和函数属性,其中规定各相似类必须定义这些函数属性定义的函数体可以多种形态),然后再将相似的函数属性用统一的接口归一化调用(统一接口的基础是各子类都规范要求了定义这些相似函数属性),从而实现了“同一接口,多种形态”

 

二、为什么要用多态性(多态性的好处)

  其实大家从上面多态性的例子可以看出,我们并没有增加什么新的知识,也就是说python本身就是支持多态性的,这么做的好处是什么呢?

1.增加了程序的灵活性

  以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如func(animal)

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)
'''

 

二、 绑定方法

绑定给类的方法(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()    

7 继承与派生

一、面向对象绑定方法

1 面向对象介绍

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)增加了程序额可扩展性

 威尼斯wns.9778官网活动, 通过继承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)

 

4 类与对象

鸭子类型

逗比时刻:

        Python崇尚鸭子类型,即‘如果看起来像、叫声像而且走起路来像鸭子,那么它就是鸭子’

        python程序员通常根据这种行为来编写程序。例如,如果想编写现有对象的自定义版本,可以继承该对象

        也可以创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度。

 

例1:利用标准库中定义的各种‘与文件类似’的对象,尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法

 1 #二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
 2 class TxtFile:
 3     def read(self):
 4         pass
 5  
 6     def write(self):
 7         pass
 8  
 9 class DiskFile:
10     def read(self):
11         pass
12     def write(self):
13         pass

 

例2:序列类型有多种形态:字符串,列表,元组,但他们直接没有直接的继承关系

 1 #str,list,tuple都是序列类型
 2 s=str('hello')
 3 l=list([1,2,3])
 4 t=tuple((4,5,6))
 5  
 6 #我们可以在不考虑三者类型的前提下使用s,l,t
 7 s.__len__()
 8 l.__len__()
 9 t.__len__()
10  
11 len(s)
12 len(l)
13 len(t)

 

2 类、实例、属性、方法详解

本文由威尼斯wns.9778官网活动发布于计算机教程,转载请注明出处:10 多态

关键词: