python学习 day21 (3月28日)----(抽象类 多态 nametuple dump）

不要因为走的路太久了，而忘记了为了什么而出发。

提前作准备了吗？把思维导图的东西做了吗？

和工作了几年的人，相比，是不是相同的水平，如果要写简历的话。

一边学习，一边复习。

小就是大，少就是多。

 1.

 1.1继承类的属性函数

class Foo:
    def __init__(self):
        self.func()

    def func(self):
        print('in foo')

class Son(Foo):
    def func(self):
        print('in son')

Son()

首先Foo会自动执行__init__(self)的内容，因为是内置的吗 ？ __init__() 和self 都是粉红色标记

Foo 和 Son 类开辟了一片空间，init 和 self 指向那片空间，

Son() 建立一个对象 开辟了一片空间  执行时， son()里的对象指针 指向子类指针寻找，子类里有 不执行父类的func()

self  里的指针指向 Son()的空间里的func() ，执行  ‘in son’

这种用法在源码里会经常用到。

1.2  

看与c3算法：

 

 

G = [GO]
D = [DO]
E = E + [GO] = [EGO]
F = [FO]
B = B + [DO] + [EGO] = [BDEGO]
C = C + [DO] + [FO] = [CDFO]
A = A + [BDEGO] + [CDFO]
A = [BDEGO] + [CDFO]
AB = [DEGO] + [CDFO]
ABC = [DEGO] + [DFO]
ABCD = [EGO] + [FO]
ABCDEGFO

看法的话从左到右，算法的话第一个执行

 

 

 

2type class(自定的和特殊的)

2.1

 

print(type(123))        #<class 'int'> 常用类
class Course:
    def __init__(self,name,price):
        self.name = name
        self.price = price
python = Course('python',20000)
print(type(python))  #<class '__main__.Course'>
#  自定义常用类
print(type(Course))
# 1、type 一个对象的时候，结果总是这个对象所属的类
# type 一个类的时候  结果是type
#  类是什么类型？？？   所有的类的类型都是type
print(type(type))
print(type(int))
#类# int str list 所有的数据类型 Course 所有的自定义的类
#对象# 123 'abc' []               python

 

2.2

2、对象 是被创造出来 被类实例化出来的
类也是被创造  特殊方式创造类
    常规的类 总有几个特性
        实例化 属性  方法

2.3

   3、元类 能够帮助你创造不同寻常的类
        特殊需求： 不能实例化
        2  ： 只能有一个实例

 类 =  type(对象)  一切皆对象
 type = type(类)
 所有的类型 说的都是 这个对象 是属于哪一个类的
 所有的用class 常规语法 创造出来的类 都是type类型

 进阶：
 元类：

 

 

 

3

3.1

抽象类：

　　框架 规范

 

 

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): # 抽象类 （越往上越抽象） # 给这个父类 建立了一个规则
    @abstractmethod   #如果我必须要实现pay方法，必须加装饰器
    def pay(self):
        pass     # 创建的pay没有内容，为了提醒所有子类一定实现pay 方法
    @abstractmethod  # 有多少规则 多少个装饰器
    def back(self):
        pass
# TypeError: Can't instantiate abstract class Payment with abstract methods back, pay
# Payment()  # 特殊类 抽象类 不能实例化
print(type(Payment))    #<class 'abc.ABCMeta'>

 

3.2

不按规划写的话

class ApplePay(Payment):
    def __init__(self,name,money):
        self.name = name
        self.money = money
    def fuqian(self):
        print('%s 通过苹果支付支付了%s'%(self.name,self.money))
# TypeError: Can't instantiate abstract class ApplePay with abstract methods pay
# 不按规划的 话  实例化不了
# app = ApplePay('liuda',2222)
# pay(app)
# 代码的规范 没有建立起来
#错误AttributeError: 'ApplePay' object has no attribute 'pay'

3.3

抽象类的调用和总结

class ApplePay(Payment):  #点进去（Payment提示）  必须有什么方法 属性 返回值 是什么样的
    pass
# 不写也没事  所以必须建立规则 ABCMEta,ab

# 抽象类  ： payment  #（架构师定）  基础人员给你垒上
#   约束所有的子类 必须实现被abstractmethod（抽象）  给子类一个框架
                #给我们的代码指定规范
# 抽象类长什么样
    #class 类名（metaclass = 'ABCMEta'）:
        #@abstractmethod
        #def 规定的方法名（self）：pass
# 文件处理
    #doc
    #txt
    #excle
# 打开文件 open
#读 read
#写 write

 

3.4

归一化：

 容易记 容易用

 

# 归一化设计
def pay(person):
    person.pay()
Wcp1 = Wechatpay('liuda',1234)
pay(Wcp1)

# 计算数据类型的长度
lst = [1,2,3]
string = '123'
print(lst.__len__())
print(string.__len__())
def len(obj):        #替换
    return obj.__len__() #正常的话不是写 __ 麻烦
#当所有的类有相同的使用，归一化   ： 容易记 容易用

4

java 中的 接口多态 和 python  中的 多继承

 

class FlyAnimal:
    def fly(self):
        pass
class SwimAnimal:
    def swim(self):
        pass
class WalkAnimal:
    def walk(self):
        pass
class Frog(SwimAnimal,WalkAnimal):pass
class Tiger(SwimAnimal,WalkAnimal):pass
class Swan(FlyAnimal,SwimAnimal,WalkAnimal):pass
class Parrot(FlyAnimal,WalkAnimal):
    def talk(self):
        pass

 

因为：

# java 当中没有多继承的类  只能继承一个父类的方法
# 不能继承多个，所以有了接口(可以多继承)  在python 里没有接口的专用语法
        # 我们只是通过类的多继承，模仿接口的效果

from abc import ABCMeta,abstractmethod
class NormalAnimal(metaclass=ABCMeta):
    @abstractmethod
    def eat(self):pass
    @abstractmethod
    def drink(self):pass
class FlyAnimal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):pass
class WalkAnimal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass
# java 写法  用的 接口多继承
class Frog(NormalAnimal,WalkAnimal):pass
class Swan(FlyAnimal,WalkAnimal):pass
class Parrot(FlyAnimal,WalkAnimal):
    def talk(self):pass

抽象类   是单继承的规范
接口类   是多继承的规范
不管单继承多继承  只要继承了父类 只要是 抽象了  都实现
java
    接口 里面定义的所有的方法，都不能写具体的实现pass
python
    抽象类的可以写一点简单的方法（eat 是一样的可以写）用super方法

 

 5

java 多态 和 python 鸭子算法

#__author : 'liuyang' 
#date : 2019/3/28 0028 上午 11:41
# 在 python 当中，处处是多态，一切接对象

# 广义的多态
#一个类能表现出的多种形态

# 木头
    # 高桌子
    # 地板凳

# 用户
# vip用户
# svip用户

# 三大特性中的多态
# java   伪代码写 （#python 不明显）
def func(username,password,c,d):
    pass
def add(a,b):
    return a+b
# def pow(int a, int b):
#     return a**b
# pow('1','2')
#  不行 默认传不过去

# 归一化设计
# def pay(type payment): 没有约束 相当于 都是type
# def pay(Payment payment):
#     payment.pay()

# 没有传参数的时候必须是什么类型的 ，所以python中处处有多种形态
# 支付有多种形态 ： 支付宝  微信支付 apple 支付


# 鸭子类型：
    #都可以传
# def len(obj):
    # list
    # str
    # tuple
    # set

# java: #告诉是什么类型的
'''         # 共同的数据类型 序列
class 序列：   
    def __len__(self):
        pass
class list(序列):  #（list、str）所有的都变成序列类型的
     def__init__(self):
        return self.length
以下数据类型 都转成 序列类型 判断是序列的然后计算长度
'''
class Person:pass
class Teacher(Person):pass
# eva_j = Teacher()  --->人
# print(isinstance(eva_j ,Person))    #True
# print(isinstance(eva_j ,Teacher))   #True

# python      啥也不用 直接多态
# 是不是迭代器 看着有个 __iter__ __next__ 就是
#len()  看着有__len__()  就可以用
# 看起来像鸭子
#鸭子类型
    #python 当中 写程序的一种特殊的情况
    #其它语言中，正常的我们说一个数据类型具有某个特点，通常是通过继承来实现的
        #继承地带器类，来证明自己本身是个迭代器
        #继承可哈希的类，来证明自己本身是可哈希的
    #但是所有的这些都不是通过继承来完成的
        #我们只是通过一种潜规则的约定，如果具有__iter__,__next__就是迭代器
        #如果具有__hash__方法就是可哈希
        #如果具有__len__就是可以计算长度的
    #这样数据类型之间的关系并不仅仅通过集成来约束的
    #而是 通过约定俗成的关系来确定的
# 比如

# list.index()
# str.index()

# java 语言特别严谨  类多 类的关系多  继承有父类约束
#python 直接用  不那么严谨 indexl

#其它语言 传参必须约定是什么数据类型 还得依靠是 继承来 执行
    # 传数据类型 才能传进来
# python 面向对象  是独特的  不需要管数据类型
    #不需要指定数据类型 就可以直接传
#多态
    # 在传递参数的时候，如果要传递的对象有可能是多个类的对象
        #我们又必须在语言中清楚的描述出到底是哪个类型的对象
        #我们就可以使用继承的形式，有一个父类作为这些所有可能传递的对象的基类
        #基础类型就可以写成这个父类
        #于是所有子类的对象都是属于这个父类的
    #在python 当中，因为要传递的对象的类型在定义阶段不需要明确，所以我们在#python中处处都是多态，
        #数据的类型不需要通过继承来维护统一
# 多态不明显  ， 鸭子类型很明显

#继承 封装 多态








#为什么学不会呢？  老师讲的还是自己？
#自己也能跟的上，昨天睡得晚，也没预习，所以平时更加可以















#昨天晚上睡得晚，担心今天上课不好 ，这种担心的心情使自己跟加谨慎了
#状态 还行

 

 6.

namedtuple

from collections import namedtuple
# 可以属性 不能改 元组  没有方法
Course = namedtuple('Course',['name','price','period'])
python = Course('python',10000,'6 months')
print(python.name)
print(python.price)
print(python.period)
print(type(python)) #<class '__main__.Course'>
# 外国人喜欢？   在 扑克牌 花色 大小  不可改的 
# 描述一个  不可改的   更明确更清晰

 

7
pickle

#__author : 'liuyang' 
#date : 2019/3/28 0028 下午 12:29
import pickle
class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period
python = Course('python',200,'1')
python1 = Course('python1',200,'1')

import pickle
# with open('pickle_file','wb')as f:
#     pickle.dump(python,f)
#     pickle.dump(python1, f)

import pickle
with open('pickle_file','rb') as f:
    obj  = pickle.load(f)
    obj2 = pickle.load(f)
# print(obj.__dict__)
# print(obj2.__dict__)

# for i in f:
    # print(i.__dict__)
# json 可以 有的  pickle 可以任意的数据类型
# 必须有类存在

 

学了东西是为了自己 不是为了 显得自己很棒  然后抱怨别人不棒