假期(面向对象相关)

"""
一、isinstance(obj,cls) 和 issubclass(sub,super)
    isinstance(obj,cls) 检查obj是否是类cls的对象
        class Bar(object):
            pass
        class Foo(object):
            pass
        obj = Foo()
        print(isinstance(obj,Foo))     #True
        print(isinstance(obj,Bar))     #False
    issubclass(sub,super) 检查sub类是否是super类的子类(派生类)
        class Bar(object):
            pass
        class Foo(Bar):
            pass
        class Te(object):
            pass
        print(issubclass(Foo,Bar))    #True
        print(issubclass(Te,Bar))     #False
"""
"""
二、反射:通过字符串的方式操作对象相关的属性,python中的一切事物都是对象,都可以使用反射
    hasattr(object,name) 判断object中有没有一个name字符串对应的方法或者是属性
    getattr(object,name,default=None)  从object中获取name属性,如果没有返回默认值None
    setattr(obj,x,y) 给obj对象设置属性x=y
    delattr(obj,x) 删除对象obj里的x属性
    类也是对象,也可以有这四个方法
    使用方法测试:
        class Foo(object):
            name = "我是你的什么啊?"
            def __init__(self,addr):
                self.addr = addr
        obj = Foo("去你大爷的")
        print(hasattr(obj,"name"))    #True
        print(getattr(obj,"name"))    #我是你的什么啊?
        setattr(obj,"sb",True)
        print(obj.__dict__)           #{‘addr‘: ‘去你大爷的‘, ‘sb‘: True}
        delattr(obj,"sb")
        print(obj.__dict__)           #{‘addr‘: ‘去你大爷的‘}
        反射当前模块成员:
            import sys
            def s1():
                print("s1")
            def s2():
                print("s2")
            this_module = sys.modules[__name__]
            print(hasattr(this_module,"s1"))
    使用反射的好处:
        实现代码的可插拔机制;在导入模块方面经常使用反射;动态的导入模块

三、__setattr__,__delattr__,__getattr__;
    #__setattr__添加/修改属性会触发它的执行
    #__delattr__删除属性的时候会触发
    #__getattr__只有在使用点调用属性且属性不存在的时候才会触发

四、二次加工标准类型(包装)
    class List(list): #继承list所有的属性,也可以派生出自己新的,比如append和mid
    def append(self, p_object):
        ‘ 派生自己的append:加上类型检查‘
        if not isinstance(p_object,int):
            raise TypeError(‘must be int‘)
        super().append(p_object)        #调用父类的append方法
    @property
    def mid(self):
        ‘新增自己的属性‘
        index=len(self)//2
        return self[index]
    实现授权的关键点就是覆盖__getattr__方法
    import time
    class FileHandle:
        def __init__(self,filename,mode=‘r‘,encoding=‘utf-8‘):
            self.file=open(filename,mode,encoding=encoding)
        def write(self,line):
            t=time.strftime(‘%Y-%m-%d %T‘)
            self.file.write(‘%s %s‘ %(t,line))

        def __getattr__(self, item):
            return getattr(self.file,item)

    f1=FileHandle(‘b.txt‘,‘w+‘)
    f1.write(‘你好啊‘)
    f1.seek(0)
    print(f1.read())
    f1.close()

五、__getattribute__:
    和__getattr__类似,不过不管是否存在都会执行
    class Foo:
        def __init__(self,x):
            self.x = x
        def __getattribute__(self, item):
            print("我总会执行")
    obj = Foo(10)
    print(obj.x)
    print(obj.xxx)
    !当getattr和getattribute同事存在的时候只执行getattribute,除非抛出异常,两者一起执行

六、描述符(__get__,__set__,__delete__):
    什么是描述符:描述符的本质就是一个新式类,在这个新式类中至少实现了__get__(),__set__(),__delete__()中的一个
                这也被称为描述符协议
    __get__():调用一个属性的时候触发
    __set__():为一个属性赋值的时候触发
    __delete__():删除属性的时候触发
        class Foo:   #这个类称为描述符
            def __get__(self, instance, owner):
                pass
            def __set__(self, instance, value):
                pass
            def __delete__(self, instance):
                pass
    描述符的作用:用来代理另外一个类的属性(必须把描述符定义为这个类的类属性,不能定义到构造方法中)
    分类:
        数据描述符:至少实现了__get__() 和__set__()方法
        非数据描述符:没有实现__set__()方法
    注意事项:
        1、描述符本身应该定义为新式类,被代理的类也应该是新式类
        2、必须定义为类属性,不能定义到构造函数中
        3、要严格遵循优先级,优先级由高到低分别是(类属性,数据描述符,实例属性,非数据描述符,找不到的时候触发__getattr__())
    描述符的使用:
    描述符的总结:

六、property:
    一个静态属性property本质就实现了get,set,delete三种方法
    用法一:
        class Foo:
            @property
            def AAA(self):
                print("get的时候运行")
            @AAA.setter
            def AAA(self,value):
                print("set的时候运行",value)
            @AAA.deleter
            def AAA(self):
                print("delete 的时候运行")
        obj = Foo()
        obj.AAA  #get
        obj.AAA = "aaa"   #set
        del obj.AAA    #delete
    用法二:
        class Foo:
            def get_AAA(self):
                print("get的时候yunx")
            def set_AAA(self,value):
                print("set 的时候运行")
            def delete_AAA(self):
                print("delete的时候运行")
            AAA=property(get_AAA,set_AAA,delete_AAA)    #内置的property三个参数必须与get,set,delete一一对应

七、__setitem__,__getitem__,__delitem__:
    示例代码;
        class Foo:
            def __init__(self,name):
                self.name = name
            def __getitem__(self, item):
                print(self.__dict__[item])
            def __setitem__(self, key, value):
                self.__dict__[key] = value
            def __delitem__(self, key):
                print("del obj 时执行")
            def __delattr__(self, item):
                print("del obj 执行,")
                self.__dict__.pop(item)
        obj = Foo("sb")
        obj["age"] = 18
        obj["age1"] = 19
        del obj.age1
        del obj["age"]
        obj["name"] = "alex"
        print(obj.__dict__)

八、__str__,__repr__,__format__:
    改变对象的字符串显示__str__,__repr__,当你打印对象的时候假如里面没有这两个方法,那么打印出来的你是看不懂的
    自定义格式化字符串:__format__
        str函数或者print函数--->obj.__str__()
        repr或者交互式解释器--->obj.__repr__()
        如果__str__没有被定义,那么就会使用__repr__来代替输出
        注意:这俩方法的返回值必须是字符串,否则抛出异常
            - 示例:
            format_dict={
                ‘nat‘:‘{obj.name}-{obj.addr}-{obj.type}‘,#学校名-学校地址-学校类型
                ‘tna‘:‘{obj.type}:{obj.name}:{obj.addr}‘,#学校类型:学校名:学校地址
                ‘tan‘:‘{obj.type}/{obj.addr}/{obj.name}‘,#学校类型/学校地址/学校名
            }
            class School:
                def __init__(self,name,addr,type):
                    self.name=name
                    self.addr=addr
                    self.type=type

                def __repr__(self):
                    return ‘School(%s,%s)‘ %(self.name,self.addr)
                def __str__(self):
                    return ‘(%s,%s)‘ %(self.name,self.addr)

                def __format__(self, format_spec):
                    if not format_spec or format_spec not in format_dict:
                        format_spec=‘nat‘
                    fmt=format_dict[format_spec]
                    return fmt.format(obj=self)
            s1=School(‘oldboy1‘,‘北京‘,‘私立‘)
            print(‘from repr: ‘,repr(s1))
            print(‘from str: ‘,str(s1))
            print(s1)

            print(format(s1,‘nat‘))
            print(format(s1,‘tna‘))
            print(format(s1,‘tan‘))
            print(format(s1,‘asfdasdffd‘))    

九、__slots__:
    在类中写一个slots,在吧类中的某些字段写在里面,外部才可以访问,不写访问不到

十、__next__和__iter__实现迭代器协议
    模拟实现range方法:
        class Range:
            def __init__(self,n,stop,step):
                self.n=n
                self.stop=stop
                self.step=step

            def __next__(self):
                if self.n >= self.stop:
                    raise StopIteration
                x=self.n
                self.n+=self.step
                return x

            def __iter__(self):
                return self

        for i in Range(1,7,3): #
            print(i)

十一、__doc__
    - 显示描述信息,即注释信息
    - 无法被继承

十二、__module__和__class__
    - __module__  表示当前操作的对象在哪个摸快
    - __class__表示当前操作的对象的类是什么

十三、__del__:
    - 析构方法:当对象在内存中被释放时执行这段代码
    - 比如在数据库链接中关闭数据库,文件操作中的close操作

十四、__enter__和__exit__:
    __enter__在进来的时候执行
    __exit__在出去的时候执行
        - 对象调用前后执行这两个方法

十五、__call__方法:
    - 对象后边+括号自动触发执行
    - 构造方法的执行是由创建对象触发的,即对象=类名();而对于__call__方法是对象()或者类()()

十六、metaclass
    exec:三个参数       字符串形式的命令  全局作用域  局部作用域
    exec会在指定的局部作用域内执行字符串内的代码,除非明确地使用global关键字
    - 类也是对象
    - 什么是元类
        - 元类是类的类,类的模板
        - 元类是用来控制如何创建类的,正如类是创建对象的模板一样,而元类的主要目的是为了控制类的创建行为元类的实例化的结
          果为我们用class定义的类,正如类的实例为对象(f1对象是Foo类的一个实例,Foo类是 type 类的一个实例)type是python的一
          个内建元类,用来直接控制生成类,python中任何class定义的类其实都是type类实例化的对象
    - 创建类的两张方式:
        - 方式一:使用class关键字
        - 方式二:手动模拟class创建类的过程
            - 类名
            - 类的父类
            - 类体
                #类名
                class_name=‘Chinese‘
                #类的父类
                class_bases=(object,)
                #类体
                class_body=
                country=‘China‘
                "
                def __init__(self,name,age):
                    self.name=name
                    self.age=age
                def talk(self):
                    print(‘%s is talking‘ %self.name)
                "
    - 一个类没有声明自己的元类,默认它的元类就是type,除了使用元类type,用户也可以通过继承type俩自定义元类
    - #元类控制类的实例化过程:
            1 类(),调用元类.__call__()
            2 在1的方法中调用:
                类.__new__() #返回类的对象obj
                类.__init__(obj,...) #为对象进行初始化

    - 元类控制类本身的产生过程

"""

原文地址:https://www.cnblogs.com/52-qq/p/8448140.html

时间: 2024-10-19 02:37:47

假期(面向对象相关)的相关文章

Java学习笔记<3>面向对象相关

面向对象的基本思想 从现实世界客观存在的事务出发来构造软件系统,并在系统的构造中尽可能运用人类的自然思维方式,如抽象.分类 继承.聚合.多态等. 类和对象的关系 对象中存储了类规定的数据类型,并且对象可以调用类的方法. java面向对象 <1>对象是java程序的核心,一切皆对象. <2>对象可以看成静态属性(成员变量)和动态属性(方法)的封装体. <3>类是创新同一类型对象的模版,定义了该类型对象应具有的成员变量及方法. 类的定义 成员变量可以用java语言的任何一种

Java之面向对象相关问题集

面向对象的特征有哪些方面  1.抽象: 抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面.抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节.抽象包括两个方面,一是过程抽象,二是数据抽象. 2.封装: 封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面.面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治.封装的对象,这些对象通过一个受保护的接口访问其他对象. 3.继承: 继承是一种联结类的层次模型,并且允许和鼓励类的重

面向对象相关概述

第一章面向对象概述 一.结构化编程与面向对象编程的区别 在程序设计的早期,程序用流程图和自顶向下的方法设计.采用这种设计方法,程序员会将一个大的问题分解成更小的任务,然后为每个更小的任务编写一个过程(或函数).最后,程序员会编写一个主过程来启动程序流程,随后根据程序流程走向,调用想要的其它过程.这种类型的程序设计被称为结构化编程. 20世纪70年代以后,面向对象编程(Object Oriented Programming,简称OOP)开始流行.OOP采用了一种完全不同的方法来开发计算机应用程序.

python——面向对象相关

其他相关 一.isinstance(obj, cls) 检查是否obj是否是类 cls 的对象 1 2 3 4 5 6 class Foo(object):     pass obj = Foo() isinstance(obj, Foo) 二.issubclass(sub, super) 检查sub类是否是 super 类的派生类 1 2 3 4 5 6 7 class Foo(object):     pass class Bar(Foo):     pass issubclass(Bar,

php的面向对象相关特性

php的面向对象与java类似,主要涉及类的声明.命名空间的使用.构造函数.静态成员.类的封装.类的继承.方法的重写等: 1)类的声明:创建[hello.php] <?php //声明一个类 class Hello{ public function sayHello(){ echo 'hello myphp'; } } //一个文件中可存在多个类 class Desk{ public function work(){ echo 'work'; } } 创建[index.php] <?php r

Python心得基础篇【7】面向对象相关

其他相关 一.isinstance(obj, cls) 检查是否obj是否是类 cls 的对象 1 class Foo(object): 2 pass 3 4 obj = Foo() 5 6 isinstance(obj, Foo) 二.issubclass(sub, super) 检查sub类是否是 super 类的派生类 1 class Foo(object): 2 pass 3 4 class Bar(Foo): 5 pass 6 7 issubclass(Bar, Foo) 三.异常处理

Python 面向对象相关

1. 类基本定义 默认构造器为只有一个self参数,内容只有一行pass. 方法:  实例方法:以实例本身self作为第一个参数. 类方法:以类对象本身cls作为第一个参数,以@classmethod修饰. 静态方法:参数无要求,以@staticmethod修饰. 变量:  实例变量:以self.开头的变量. 类变量:在类定义后.方法外定义的变量. 变量的引用:  类变量: self.__class__.class_field_name:这种方法肯定成功. self.class_field_na

面向对象相关知识总结

//1.hasOwnPrototype 判断是都是当前对象的自有属性 var obj ={name:"zhangsan"}; console.log(obj.hasOwnProperty("name"));//true //2.isPrototypeOf 判断是否是传入对象的原型对象 functionFun(){} var fun=newFun(); console.log(Fun.prototype.isPrototypeOf(fun));//true //con

面向对象相关

重载.重写.重用 作用域:重载函数,它们的作用域相同:而重写和重用的函数作用域不同,出现在继承关系中. 重载:函数名必须相同,但是函数参数列表必须不同,返回值无所谓. 重写:函数名,参数列表和返回值类型都必须相同.出现于虚函数中,也叫覆盖. 重用:函数名相同即可,出现于派生类重用定义了其基类中的函数名字,也叫隐藏.可以通过作用域来调用被隐藏的函数.重用体现了C++中一条规则--名字查找先于类型检查. 基类作用域与派生类作用域 派生类作用域嵌套于基类作用域之内,所以派生类才可以像使用自己的成员一样