zoukankan      html  css  js  c++  java
  • 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()
    V看代码的题

    首先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
    View Code
    看法的话从左到右,算法的话第一个执行

    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
    View Code

    2.2

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

    2.3

       3、元类 能够帮助你创造不同寻常的类
            特殊需求: 不能实例化
            2  : 只能有一个实例
    
     类 =  type(对象)  一切皆对象
     type = type(类)
     所有的类型 说的都是 这个对象 是属于哪一个类的
     所有的用class 常规语法 创造出来的类 都是type类型
    
     进阶:
     元类:
    View Code

    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'
    View Code

    3.3

    抽象类的调用和总结

    class ApplePay(Payment):  #点进去(Payment提示)  必须有什么方法 属性 返回值 是什么样的
        pass
    # 不写也没事  所以必须建立规则 ABCMEta,ab
    
    # 抽象类  : payment  #(架构师定)  基础人员给你垒上
    #   约束所有的子类 必须实现被abstractmethod(抽象)  给子类一个框架
                    #给我们的代码指定规范
    # 抽象类长什么样
        #class 类名(metaclass = 'ABCMEta'):
            #@abstractmethod
            #def 规定的方法名(self):pass
    # 文件处理
        #doc
        #txt
        #excle
    # 打开文件 open
    #读 read
    #写 write
    View Code

    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
    python的多继承

    因为:

    # 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 的接口类 类似于多个抽象类 完成的多继承
    抽象类   是单继承的规范
    接口类   是多继承的规范
    不管单继承多继承  只要继承了父类 只要是 抽象了  都实现
    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中处处都是多态,
            #数据的类型不需要通过继承来维护统一
    # 多态不明显  , 鸭子类型很明显
    
    #继承 封装 多态
    
    
    
    
    
    
    
    
    #为什么学不会呢?  老师讲的还是自己?
    #自己也能跟的上,昨天睡得晚,也没预习,所以平时更加可以
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    #昨天晚上睡得晚,担心今天上课不好 ,这种担心的心情使自己跟加谨慎了
    #状态 还行
    View Code

     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'>
    # 外国人喜欢?   在 扑克牌 花色 大小  不可改的 
    # 描述一个  不可改的   更明确更清晰
    namedtuple 建类不可改
    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 可以任意的数据类型
    # 必须有类存在
    View Code
    学了东西是为了自己 不是为了 显得自己很棒  然后抱怨别人不棒



  • 相关阅读:
    智能推荐算法演变及学习笔记(三):CTR预估模型综述
    从中国农业银行“雅典娜杯”数据挖掘大赛看金融行业数据分析与建模方法
    智能推荐算法演变及学习笔记(二):基于图模型的智能推荐(含知识图谱/图神经网络)
    (设计模式专题3)模板方法模式
    (设计模式专题2)策略模式
    (设计模式专题1)为什么要使用设计模式?
    关于macOS上常用操作命令(持续更新)
    记录下关于RabbitMQ常用知识点(持续更新)
    EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY'RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.
    SpringCloud教程二:Ribbon(Finchley版)
  • 原文地址:https://www.cnblogs.com/Doner/p/10612700.html
Copyright © 2011-2022 走看看