2019-03-28-day021-抽象类与接口类

今日内容

1. type和class
2. 继承
   • 抽象类
   • 接口类
3. 多态
   • java
   • 鸭子类型
4. pickle模块
5. 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用户

三大特性中的多态

• java

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

• list
• str
• dict
• tuple
• set

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