今日内容
- type和class
- 继承
- 多态
- pickle模块
- collections.namedtuple
type和class
##type
##class
print(type(123))
class Course:
def __init__(self,name,price):
self.name = name
self.price = price
python = Course('python',20000)
print(type(python))
type一个对象的时候,结果总是这个对象所属的类
类是什么类型???所有的类的类型都是type
print(type(Course))
print(type(int))
print(type(str))
- 对象是被创造出来 被类实例化出来的
- 类也是被创造出来的 特殊的方式来创造类
- 常规创造的类 总是有几个特性
- 元类 能够帮助你创造不同寻常的类
- 特殊的需求一 : 不能实例化
- 特殊的需求二 : 只能有一个实例
- 类 = type(对象)
- type = type(类)
- 所有的类型 说的都是这个对象是属于哪一个类的
- 所有的用class常规语法创造出来的类 都是type类型
- 进阶
抽象类
微信支付
支付宝支付
class Wechatpay:
def __init__(self,name,money):
self.name = name
self.money = money
def pay(self):
print('%s通过微信支付了%s元'%(self.name,self.money))
class Alipay:
def __init__(self,name,money):
self.name = name
self.money = money
def pay(self):
print('%s通过支付宝支付了%s元'%(self.name,self.money))
class ApplePay:
def __init__(self,name,money):
self.name = name
self.money = money
def fuqian(self):
print('%s通过apple pay支付了%s元' % (self.name, self.money))
归一化设计
def pay(person):
person.pay()
wcp = Wechatpay('alex',2000000)
pay(wcp)
ali = Alipay('alex',2000000)
app = ApplePay('alex',2000000)
pay(app)
代码的规范没有建立起来
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): # 抽象类
@abstractmethod # 如果我必须要实现pay方法,那么我需要给pay加一个装饰器
def pay(self):
pass # 创建的这个pay并没有内容,
# 之所以写一个pay是为了提醒所有子类你一定要实现一个pay方法
@abstractmethod
def back(self):
pass
class Wechatpay(Payment):
def __init__(self,name,money):
self.name = name
self.money = money
def pay(self):
print('%s通过微信支付了%s元'%(self.name,self.money))
class Alipay(Payment):
def __init__(self,name,money):
self.name = name
self.money = money
def pay(self):
print('%s通过支付宝支付了%s元'%(self.name,self.money))
class ApplePay(Payment):
def __init__(self, name, money):
self.name = name
self.money = money
def pay(self):
print('%s通过apple pay支付了%s元' % (self.name, self.money))
def back(self):
print('退款')
归一化设计
def pay(person):
person.pay()
ApplePay('alex',20000)
- 抽象类 :Payment这个类是一个抽象类
- 抽象类做什么事儿 : 约束所有的子类 必须实现被abstractmethod装饰的方法名
给我们的代码指定规范
- 特点 : 抽象类不能实例化,只是作为具体的类的规范
抽象类长什么样
class 类名(metaclass = 'ABCMeta'):
@abstractmethod
def 规定的方法名(self):pass
@abstractmethod
def 规定的方法名(self):pass
@abstractmethod
def 规定的方法名(self):pass
接口类
类只能单继承,所以抽象类 只能是所有的子类只有一个规范
- java 当中没有多继承的类
- 在python里没有接口的专用语法
from abc import ABCMeta,abstractmethod
class NormalAnnimal(metaclass=ABCMeta):
@abstractmethod
def eat(self):pass
@abstractmethod
def drink(self):pass
class FlyAnimal(metaclass=ABCMeta):
@abstractmethod
def fly(self):pass
class SwimAnimal(metaclass=ABCMeta):
@abstractmethod
def swim(self):pass
class WalkAnimal(metaclass=ABCMeta):
@abstractmethod
def walk(self):pass
class Frog(NormalAnnimal,SwimAnimal,WalkAnimal):
def eat(self):
pass
class Tiger(NormalAnnimal,SwimAnimal,WalkAnimal):pass
class Swan(NormalAnnimal,FlyAnimal,SwimAnimal,WalkAnimal):pass
class Parrot(NormalAnnimal,FlyAnimal,WalkAnimal):
def talk(self):
pass
抽象类 是单继承的规范
接口类 是多继承的规范
- java
- 接口里面定义的所有的方法 都不能写具体的实现 pass
- 抽象类里面定义的所有的抽象方法 内部是可以完成一些简单的代码
多态
在python当中 处处是多态,一切皆对象
广义的多态:
- 一个类能表现出的多种形态
- 木头
- 高桌子
- 低板凳
======
- 用户
- vip用户
- svip用户
三大特性中的多态
def func(str username,str password):
username.strip()
def pow(int a,int b):
return a**b
pow('a','b')
#例子
class Payment:pass
class Alipay(Payment):
def __init__(self,name,money):
self.name = name
self.money = money
def pay(self):
print('%s通过支付宝支付了%s元'%(self.name,self.money))
class ApplePay(Payment):
def __init__(self,name,money):
self.name = name
self.money = money
def pay(self):
print('%s通过apple pay支付了%s元' % (self.name, self.money))
归一化设计
def pay(Payment person):
person.pay()
#支付有多种形态 : 支付宝 微信支付 apple支付
鸭子类型
class 序列:
def __len__(self):
pass
class list(序列):
def __init__(self):
self.length = 0
def __len__(self):
return self.length
def len(序列 obj):
class Person:pass
class Teacher(Person):pass
taibai = Teacher()
print(isinstance(taibai,Person))
print(isinstance(taibai,Teacher))
python
啥也不用
是不是一个迭代器
__iter__ __next__
len()
__len__()
- 鸭子类型
- python当中写程序的一种特殊的情况
- 其他语言中 正常的我们说一个数据类型具有某个特点,通常是通过继承来实现
- 继承迭代器类,来证明自己本身是个迭代器
- 继承可哈希的类,来证明自己本事是可哈希的
- 但是所有的这些都不是通过继承来完成的
- 我们只是通过一种潜规则的约定,如果具有__iter__,__next__就是迭代器
- 如果具有__hash__方法就是可哈希
- 如果具有__len__就是可以计算长度的
- 这样数据类型之间的关系并不仅仅是通过继承来约束的
- 而是通过约定俗成的关系来确认的
- 多态
- 在传递参数的时候,如果要传递的对象有可能是多个类的对象
- 我们又必须在语言中清楚的描述出到底是那一个类型的对象
- 我们就可以使用继承的形式,有一个父类作为这些所有可能被传递进来的对象的基类
- 基础类型就可以写成这个父类
- 于是所有子类的对象都是属于这个父类的
- 在python当中,因为要传递的对象的类型在定义阶段不需要明确,所以我们在python中处处都是多态
namedtuple
from collections import namedtuple
Course = namedtuple('Course',['name','price','period'])
python = Course('python',20000,'6 month')
print(python.name)
print(python.price)
print(python.period)
print(type(python))
pickle
import pickle
class Course:
def __init__(self,name,price,period):
self.name = name
self.price = price
self.period = period
python = Course('python',20000,'6 months')
linux = Course('linux',15800,'5 months')
import pickle
with open('pickle_file','ab') as f:
pickle.dump(python,f)
pickle.dump(linux,f)
import pickle
with open('pickle_file','rb') as f:
# obj1 = pickle.load(f)
# obj2 = pickle.load(f)
while True:
try:
obj = pickle.load(f)
print(obj.__dict__)
except EOFError:
break