• 面向对象串讲


    '''
    文件处理
        read(3):
            1 文件打开方式为文本模式时,代表读取3个字符
            2 文件打开模式为b模式时,代表读取3个字节
            
        f.tell() 指针位置为
        
        文件指针移动
            f.seek(offset,whence)
            
            offset --开始的偏移量,也就是代表需要移动偏移的字节数
            whence:可选,默认值为0 给offset参数一个定义,表示要从哪个位置开始偏移
                0 代表从文件开头开始算起 
                1 代表从当前位置开始算起  b模式下
                2 代表从文件末尾算起   b模式下
            
            
            f.seek(0,2) 偏移量0 移动到文件尾位置
    
    函数:函数就是实现某一功能的工具
        函数的基本使用(原则:先定义,后调用)
            定义阶段发生什么事:只检测语法,不执行代码
    
    
    
    面向过程思想:
        核心是‘过程’二字,过程指的是解决问题的步骤是,先干什么在干什么
        基于该思想编写程序,相当于一条流水线,一种机械式的思维方式
    
    面向对象思想:
        核心是 对象 二字,对象指的是数据与方法的结合体。也就是容器
        基于该思想编写程序,就好比创造世界,一种上帝式的思维方式。
        
    
    面向对象
        面向对象的核心就是对象二字,对象(对象就是容器,箱子)的精髓在于'整合'
    
    
    1类与对象
        对象是特征与技能的结合体,即数据与方法。 容器/名称空间
        类则是一系列对象相似的特征与技能的结合体,即相似的数据与方法。 容器/名称空间
        
        类的两种用途:
            1 当容器去用
                类的数据属性
                类的函数属性
            2 调用类的过程称之为实例化,结果就是对象
                实例化时方式两件事:
                    1 先产生一个空对象
                    2 触发__init__(空对象,arg1,age2....)
                    
        面向对象三大特性
            封装:
                把一堆数据属性与方法方法属性 整合 到对象里面。
                
            隐藏:
                __属性----》把属性变形了,即隐藏起来了!
            
            继承:
                父类是一些类共有的数据属性与方法属性的结合体
                子类可以继承父类的属性,还可以派生出自己独有的属性
            
            组合:
                1 即继承父类的属性,且不与父类耦合到一起
                2 把一个对象作为另一个对象的属性
                组合是继承的一种应用
            
            多态:
                1 抽象类
                2 鸭子类型
            
        对象的绑定方法
            给对象用的,由对象来调用,会自动把对象本身当做第一个参数传给self
        
        classmethod  staticmethod(非绑定方法) property
        
            property 装饰器 将被装饰的方法属性伪装成数据属性(像对象的name age sex之类的) 会自动加括号 然后内部代码是return出去返回值
            然后外部调用的时候就和调用数据属性类似 
        
    
    2继承与派生
        1 什么是继承
            继承是一种新建类的方式,新建的类称之为子类/派生类,被继承类称之为父类/超类/基类
    
            继承描述的是一种遗传的关系,特点:
                1 子类可以遗传/重用父类的属性(减少代码冗余)
                2 一个子类可以同时继承多个父类
                3 在继承的背景下,类分为新式类与经典类
    
            子类如何重用父类属性?
            在继承背景下属性的查找顺序??
            新式类 经典类
    
        2 为何要用继承
            解决类与类之间代码冗余的问题
    
        3 如何继承
         class Foo:
                pass
    
            class Bar(Foo):
                x=1
    
            obj=Bar()
    
         4 在子类派生新方法中重用父类功能的两种方式:
            方式一:指名道姓地访问某一个类的函数
                特点:
                    1:与继承无关
                    2:没有自动传值的效果
            方式二:super(自己的类名,self)会得到一个特殊的对象,该对象专门用来访问'父类'中的属性,完全参照mro列表
                特点:
                    1 严格依赖继承,完全参照mro列表
                    2 有自动传值的效果
    
    3 组合
        1 什么是组合
            组合指的是一个对象拥有某一个属性,该属性的值来自于另一个类的对象
                 class OldboyStudent:
                pass
    
            class OldboyTeacher:
                pass
    
            class Course:
                pass
    
    
            stu=OLdboyStudent()
            tea=OLdboyTeacher()
    
            obj=Course()
    
            stu.attr=obj
            tea.attr=obj
    
        2 为何要用组合
            解决类与类之间代码冗余的问题(例子是 教务系统管理员 与老师学生的初始化相同,老师与学生有选课功能)
    
    
    4 多态
        多态指的是同一种事物的多种形态
        多态性:指的是可以在不用考虑具体类型前提下而直接使用对象
        多态的精髓就是'统一' 二字
    
        python 崇尚鸭子类型
    
    5面向对象高级:
        1 反射:
            通过 字符串 来操作类与对象的属性
            hasattr()
                判断对象或者类的属性是否存在
                
            getattr()
                获取对象或类的属性
                参数1:对象(类也对象,存有数据属性,方法属性)
                参数2:‘属性名’
                参数3: 默认值 不存在的时候不会异常
            
            setattr()
                设置对象或者类的属性
                不存在则新建
            delattr()
                删除对象或类的属性
            
            
        
        2类的内置方法
            __init__(): 调用类的时候自动触发__init__。
            __str__():  在对象被打印时自动触发 可以自定义打印对象的内容(此方法内,必须return一个字符串类型的值)
            __del__:在对象被删除时先自动触发该方法,可以用来回收对象以外其他相关资源,比如系统资源
    
    '''
    
    # 一 绑定方法:绑定给谁就应该由谁类调用,谁类调用就会将谁当做第一个参数传入
    #  1绑定给对象的方法:类中定义的函数默认就是绑定给对象的
    #  2绑定给类的方法:为类中定义的函数加上一个装饰器classmethod
    
    
    # 二:非绑定方法:即不与类绑定,又不与对象绑定,意味着对象和类都可以调用,无论谁来调用都是一个普通的函数,没有自动传值的效果
    
    # class Foo:
    #     def f1(self):
    #         print(self)
    #
    #     @classmethod
    #     def f2(cls):
    #         print(cls)
    #
    #     @staticmethod
    #     def f3(x,y):
    #         print('f3',x+y)
    #
    #
    # obj=Foo()
    # # print(obj.f1)
    # # obj.f1()
    #
    # # print(Foo.f2)
    # # Foo.f2()
    # # print(obj.f2)
    # # obj.f2()
    #
    # print(Foo.f3)
    # print(obj.f3)
    #
    # Foo.f3(1,2)
    # obj.f3(3,4)
    
    # 应用
    
    # import  settings #导入settings下面的IP 和port
    # class MySql:
    #     def __init__(self,ip,port):
    #         self.id=self.create_id()
    #         self.ip=ip
    #         self.port=port
    #
    #     def tell_info(self):
    #         print('id:%s ip:%s port:%s'%(self.id,self.ip,self.port))
    #
    #     @classmethod  #提供额外的实例化方式,从配置文件中加载配置
    #     def from_conf(cls):
    #         return cls(settings.IP,settings.PORT)
    #
    #     @staticmethod
    #     def create_id():
    #         import uuid
    #         return uuid.uuid4()
    #
    # # obj2=MySql('1.2.2.','3306')
    # obj2=MySql.from_conf()
    # # print(obj2.__dict__)
    #
    #
    # obj2.tell_info()
    
    class Bar:
        pass
    class Foo(Bar):
        pass
    
    print(issubclass(Foo,Bar)) #True   判断Foo是否是Bar的子类
    
    obj=Foo()
    print(isinstance(obj,Foo))  #True 判断obj是否是Foo的类型
  • 相关阅读:
    BZOJ3209: 花神的数论题
    BZOJ3207: 花神的嘲讽计划Ⅰ
    BZOJ3155: Preprefix sum
    BZOJ2465: [中山市选2009]小球
    BZOJ2243: [SDOI2011]染色
    BZOJ1192: [HNOI2006]鬼谷子的钱袋
    hdu1542(线段树——矩形面积并)
    hdu4578(线段树)
    hdu4614(线段树+二分)
    hdu3974(线段树+dfs)
  • 原文地址:https://www.cnblogs.com/lakei/p/10759146.html
Copyright © 2020-2023  润新知