类型这块
type 一个对象的时候,这个对象的类型,总是这个对象所属的类
type任何一个类,它的类型都是type,type是所有数据类型和类的鼻祖
type的类型是它本身 type = type(type)
函数的类型就是函数
python是一种动态语言,一个鸭子类型举例:动态python变量,在赋值的时候,赋值号(=)右边的数据类(list,set,float等)对象是什么类型,他就是什么类型
a. 常规创造的类 总是有几个特性:
能够实例化
能有属性
能有方法
b.元类能够帮助你创造不同寻常的类(下面就来了)
不能实例化
只能有一个实例
类 =type(该类对象)
type = type(类)
所有的类型:说的都是这个对象是属于哪一类的
所有的用class常规语法创造出来的类都是type类型
‘
元类的应用(归一化设计)
归一化设计
a.方便用户记忆
b.方便用户使用
python 的归一化设计用的是一下的东西:
from abc import ABCMeta,abstractmethod class Father(metaclass= ABCMeta): #抽象类,如果你用了这种, def __init__(self,name,price): #在@abstractmethod方法下面函数,在此类的每一个 self.name = name #子函数必须实现该函数,但是在此类此函数可以写一些 self.price = price #简单代码,抽象类也不能实例化 @abstractmethod def pay(self): pass class Wechatpay(Father): def pay(self): print(f‘{self.name}付了{self.price}‘) class Alipay(Father): def pay(self): print(f‘{self.name}付了{self.price}‘) def pay(person): #归一化设计 就是将zy.pay() = pay(zy) return person.pay() #方便用户记忆 #方便用户使用 zy = Wechatpay(‘zy‘,1000) hfl = Alipay(‘hfl‘,2000) pay(zy) pay(hfl)
多变化的抽象类继承
from abc import ABCMeta,abstractmethodclass Normalanimals(metaclass=ABCMeta): @abstractmethod def eat(self): pass @abstractmethod def drink(self): pass
class Flyanimals(metaclass=ABCMeta): @abstractmethod def fly(self): pass class Swimanimals(metaclass=ABCMeta): @abstractmethod def swim(self): pass class Tiger(Normalanimals,Swimanimals): def eat(self):pass def drink(self):pass def swim(self):pass class swam(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 import namedtuple Course = namedtuple(‘Course‘,[‘name‘,‘ad‘,‘hp‘]) python = Course(‘python‘,100,120) print(python.name) #只能这样做 # print(python.__dict__) 不可行 ,连特么的呈现内容都呈现不出来,看来跟常量的性质一样 class A: 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_mon 7
pickle的意义
import pickle class A(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等)对象是什么类型 它就是什么类型
原文地址:https://www.cnblogs.com/CNHK1949/p/10617038.html