python 多态应用_python 多态这一部分的知识点相关应用

类型这块

type 一个对象的时候，这个对象的类型，总是这个对象所属的类

type任何一个类，它的类型都是type，type是所有数据类型和类的鼻祖

type的类型是它本身 type  = type(type)

函数的类型就是函数

python是一种动态语言，一个鸭子类型举例：动态python变量，在赋值的时候，赋值号(=)右边的数据类(list，set，float等)对象是什么类型，他就是什么类型

a. 常规创造的类 总是有几个特性:

能够实例化

能有属性

能有方法

b.元类能够帮助你创造不同寻常的类(下面就来了)

不能实例化

只能有一个实例

类 =type(该类对象)

type = type(类)

所有的类型：说的都是这个对象是属于哪一类的

所有的用class常规语法创造出来的类都是type类型

‘

元类的应用(归一化设计)

归一化设计

a.方便用户记忆

b.方便用户使用

python 的归一化设计用的是一下的东西：

fromabc import ABCMeta,abstractmethodclass Father(metaclass=ABCMeta): #抽象类，如果你用了这种，

def __init__(self,name,price): #在@abstractmethod方法下面函数，在此类的每一个

self.name=name #子函数必须实现该函数，但是在此类此函数可以写一些

self.price=price #简单代码，抽象类也不能实例化

@abstractmethod

def pay(self):

passclassWechatpay(Father):

def pay(self):

print(f'{self.name}付了{self.price}')classAlipay(Father):

def pay(self):

print(f'{self.name}付了{self.price}')

def pay(person): #归一化设计 就是将zy.pay()=pay(zy)returnperson.pay() #方便用户记忆

#方便用户使用

zy= Wechatpay('zy',1000)

hfl= Alipay('hfl',2000)

pay(zy)

pay(hfl)

from abc importABCMeta,abstractmethodclass A(metaclass=ABCMeta):

@classmethod

@abstractmethoddeffunc(cls):print('in func')classB(A):def __init__(self,name):

self.name=namedeffunc(self):print('ss')

A.func()

c= B('alex')print(c.name)

^在此类此函数可以写一些简单代码，这么做就ok了,将这个抽象方法定义成类方法，在外部用类名调用

多变化的抽象类继承

from abc import ABCMeta,abstractmethod

class Normalanimals(metaclass=ABCMeta):

@abstractmethod

def eat(self):

pass

@abstractmethod

def drink(self):

pass

class Flyanimals(metaclass=ABCMeta):

@abstractmethod

def fly(self):

passclass Swimanimals(metaclass=ABCMeta):

@abstractmethod

def swim(self):

passclassTiger(Normalanimals,Swimanimals):

def eat(self):pass

def drink(self):pass

def swim(self):passclassswam(Normalanimals,Swimanimals,Flyanimals):

def eat(self):pass

def drink(self):pass

def swim(self):pass

def fly(self):pass

鸭子类型：

python当中写程序的一种特殊的情况

其他语言中 正常的我们说一个数据类型具有某个特点，通常是通过继承来实现

继承迭代器类，来证明自己本身是个迭代器

继承可哈希的类，来证明自己本身是可哈希的

但是所有的这些都不是通过继承来完成的

我们只是通过一种潜规则的约定，如果具有__iter__,__next__就是迭代器

如果具有__hash__方法就是可哈希的

如果具有__len__就是可以计算长度的

这样的数据类型之间的关系并不仅仅是通过继承来约束的

而是通过约定俗成的关系来确认的

list.index()

str.index()

鸭子类型是一种约定俗称的关系,只在python里有

多态：

在传递参数的时候，如果要传递的参数有可能是多个类的对象

我们又必须在于严重清楚的描述出到底是哪一个类型的对象

我们就可以使用继承的形式，有一个父类作为这些所有可能被传递进来的对象的基类

基础类型就可以写成这个父类了

于是所有子类的对象都是属于这个父类的

在python当中，因为要传递的对象的类型在定义阶段不需要明确，所以我们在python中处处是多态

数据类型不需要通过继承来维护统一

命名元组

创建一个不可以更改属性，没有自带方法的类

调用的时候用 from collections import nametuple

对比：通过这个对比，我们知道这个类只能做调用单个参数值，连呈现内容都做不到，看来跟常量性质一样了from collections importnamedtuple

Course= namedtuple('Course',['name','ad','hp'])

python= Course('python',100,120)print(python.name) #只能这样做#print(python.__dict__) 不可行 ，连特么的呈现内容都呈现不出来，看来跟常量的性质一样

classA:def __init__(self,name,ad,hp):

self.name=name

self.ad=ad

self.hp=hp

c= A('zy',12,34)print(c.__dict__)

还有一种命名元组你想到了么？

嘿嘿，那就是time时间模块里的 struct_time

它是通过 time.localtime 获取，它的也是一个struct_time类，但是它的属性更nametuple一样不可更改，也不可以添加

也没有自己的方法

>>>time.localtime()

time.struct_time(tm_year=2014, tm_mon=7, tm_mday=8, tm_hour=22, tm_min=9, tm_sec=1, tm_wday=1, tm_yday=189, tm_isdst=0)>>> time.localtime()[1]7

>>>time.localtime().tm_mon7

pickle的意义

importpickleclassA(object):def __init__(self,name,hp,ad)

self.name=name

self.hp=hp

self.ad=ad

person= A('zy',100,10)

with open('t1','wb') as f1:

pickle.dump(person,f1)

with open('t1','rb')as f2:

c=pickle.load(f2)print(c.__dict__)

总结：

多态的实现在其他语言中用继承来实现，比如Java用接口实现多继承

在python当中是通过鸭子类型来实现，弱类型语言的意思就是不同类型的变量不允许相加

python还是一种动态语言，一个鸭子类型举例 动态python变量，在赋值的时候，赋值号(=)右边的数据类(list，set，int，float等)对象是什么类型 它就是什么类型