zoukankan      html  css  js  c++  java
  • python 全栈开发,Day23(复习,isinstance和issubclass,反射)

    一、复习

    class A:
        def func1(self):pass
        def func2(self): pass
        def func3(self): pass
    a = A()
    b = A()
    print(A.func1)
    print(a.func1)
    print(b.func1)
    

    执行输出:

    <function A.func1 at 0x00000286A24EAA60>
    <bound method A.func1 of <__main__.A object at 0x00000286A2381048>>
    <bound method A.func1 of <__main__.A object at 0x00000286A2381358>>

    bound 表示绑定的意思。当类A实例化时,会将里面的方法与做类做绑定。

    class A:
        def func1(self):pass  # 对象与方法之间的绑定
        @classmethod
        def func2(self): pass  # 类与方法之间的绑定
        @classmethod
        def func3(self): pass
    a = A()
    b = A()
    #普通方法 对象和类绑定的过程
    print(A.func2)
    print(a.func2)  # 对象能找到类 类里面绑着方法
    print(b.func2)

    执行输出:

    <bound method A.func2 of <class '__main__.A'>>
    <bound method A.func2 of <class '__main__.A'>>
    <bound method A.func2 of <class '__main__.A'>>

    类方法 由于不适用对象内存空间中的属性,所以不会将对象和方法绑在一起
    而是将类和方法绑在一起

    class A:
        def func1(self):pass  # 对象与方法之间的绑定
        @classmethod
        def func2(self): pass  # 类与方法之间的绑定
        @staticmethod
        def func3(self): pass  # 静态方法
    a = A()
    b = A()
    print(A.func3)
    print(a.func3)
    print(b.func3)
    

    执行输出:

    <function A.func3 at 0x0000027EB99EA9D8>
    <function A.func3 at 0x0000027EB99EA9D8>
    <function A.func3 at 0x0000027EB99EA9D8>

    静态方法 不是绑定方法 没有和对象或者类发生任何绑定关系

    python处处皆对象

    'a' 是str的对象

    [1,2,3] 是list的对象

    派生

    class Foo:
        def __init__(self,name):
            self.name = name
            self.age = 18
    
    class Son(Foo):pass
    son = Son('egon')
    print(son.__dict__)
    

    执行输出:

    {'name': 'egon', 'age': 18}

    这里面没有派生属性(子类有,父类没有的属性)

    增加一个派生属性

    class Foo:
        def __init__(self,name):
            self.name = name
            self.age = 18
    
    class Son(Foo):pass
    son = Son('egon')
    son.money = 500  # 在类外部添加一个属性
    print(son.__dict__)
    

    执行输出:

    {'money': 500, 'name': 'egon', 'age': 18}

    第二种方式,添加派生属性

    class Foo:
        def __init__(self,name):
            self.name = name
            self.age = 18
    
    class Son(Foo):
        def __init__(self,name,money):
            Foo.__init__(self,name)
            self.money = money  # 初始化添加属性
    
    son = Son('egon',500)
    print(son.__dict__)
    

    执行输出:

    {'age': 18, 'money': 500, 'name': 'egon'}

    age重新赋值

    class Foo:
        def __init__(self,name):
            self.name = name
            self.age = 18
    
    class Son(Foo):
        def __init__(self,name,money):
            Foo.__init__(self,name)
            self.age = 20  # 重新赋值
            self.money = money  # 初始化添加属性
    
    son = Son('egon',500)
    print(son.__dict__)
    

    执行输出:

    {'name': 'egon', 'money': 500, 'age': 20}

    在抽象类里面,当一个类指定ABCMeta,就不能实例化了

    面向对象总结,请参考图

    https://www.processon.com/view/link/5ad6a594e4b0f5fa24e09235

    二、isinstance和issubclass

    isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。
    isinstance() 与 type() 区别:
      type() 不会认为子类是一种父类类型,不考虑继承关系。
      isinstance() 会认为子类是一种父类类型,考虑继承关系。
    如果要判断两个类型是否相同推荐使用 isinstance()。

    a = 2
    print(isinstance (a,int))  # 判断是否为整形

    执行输出: True

    判断继承关系

    class A:pass
    class B:pass
    class A(B):pass
    a = A()
    print(isinstance(a,A))
    print(isinstance(a,B))  # 能够检测到继承关系
    print(type(a) is A)
    print(type(a) is B)  # type 只单纯的判断类型

    执行输出:

    True
    True
    True
    False

    isinstance判断一个对象和一个类有没有血缘关系

    issubclass(sub, super)检查sub类是否是 super 类的派生类

    issubclass 检测子类,父类关系

    class C:pass
    class D(C):pass
    print(issubclass(C,D))
    print(issubclass(D,C))

    执行输出:

    False
    True

    issubclass(子类名,父类名) 如果返回True,说明有继承关系

    多继承

    class B:pass
    class C(B):pass
    class D(C):pass
    print(issubclass(C,D))
    print(issubclass(D,C))
    print(issubclass(B,C))
    print(issubclass(C,B))
    print(issubclass(D,B))
    

    执行输出:

    False
    True
    False
    True
    True

    这2个方法,不常用

    三、反射

    反射非常重要,如果一个知识点,重要程度是5颗星的话,那么反射是6星重点掌握!!!!

    1. 什么是反射
    反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

    2. python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)
    反射就是通过字符串的形式,导入模块;通过字符串的形式,去模块寻找指定函数,并执行。利用字符串的形式去对象(模块)中操作(查找/获取/删除/添加)成员,一种基于字符串的事件驱动!


    先来介绍四个内置函数:

    ✴✴✴✴✴✴hasattr 判断值是否存在
    ✴✴✴✴✴✴getattr 获取值
    setattr 修改和新建
    delattr 删除一个属性

    参数形式:

    hasattr(obj, attr):
    这个方法用于检查obj是否有一个名为attr的值的属性,返回一个布尔值。
    getattr(obj, attr):
    调用这个方法将返回obj中名为attr值的属性的值,例如如果attr为'bar',则返回obj.bar。
    setattr(obj, attr, val):
    调用这个方法将给obj的名为attr的值的属性赋值为val。例如如果attr为'bar',则相当于obj.bar = val
    delattr(obj, name)
    参数是由一个对象和一个字符串组成的。string参数必须是对象属性名之一。该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar

     先来讲eval

    role = 123
    print(eval('role'))
    

    执行输出: 123

    class A:
        role = 'Person'
    print(A.__dict__['role'])
    

    执行输出:

    Person

    根据输入内容,测试获取的类的属性

    class A:
        role = 'Person'
    ret = input('>>>')
    print(A.__dict__[ret])
    

    执行输出:

    >>>role
    Person

    那么问题来,如果获取一个函数呢?

    def func():pass
    ret = input('>>>')
    eval(ret)
    

    如果植入一段代码,删除根目录,那么linux系统就完了。。。

    import os;os.remove('/')

    所以eval不能随便用,这样写没有安全意识
    input的内容,没法估量,有可能是病毒或者恶意代码

     hasattr和getattr的组合使用

    class A:
        role = 'Person'
    
    if hasattr(A,'role'):  # 判断role属性在A中是否存在
        print(getattr(A,'role'))  # 获取role属性的值
        
    

    执行输出:

    Person

    getattr 使用字符串数据类型的变量名 访问一个命名空间中的名字

    前提是,必须指定类的命名空间
    比如A,'role'

    如果getattr获取不到值,直接报错,所以一般和hasattr配合使用

    类中的方法也是可以的获取的

    从A的命名空间里找一个方法 ,找到的是这个方法的内存地址

    class A:
        role = 'Person'
        def func(self):
            print('*'*self)
    
    if hasattr(A,'func'):  # 判断func方法在A中是否存在
        print(getattr(A,'func'))  # 获取func方法的值
    

    执行输出:

    <function A.func at 0x000001E95F8FAA60>

    class A:
        role = 'Person'
        def func(self):
            print('*'*self)
    
    if hasattr(A,'func'):  # 判断func方法在A中是否存在
        print(getattr(A,'func'))  # 获取func方法的值
        #下面三行代码,效果一样
        f = getattr(A,'func');f(1)
        getattr(A,'func')(1)
        #上面2行,是用的字符串方法
        A.func(1)
    

    执行输出:

    <function A.func at 0x00000217CBC0AA60>
    *
    *
    *

    反射
    正常情况下如果可以拿到这个变量 那么如有有这个变量的字符串形式 就是用反射可以获取到这个值
    使用字符串数据类型的变量名 访问一个命名空间中的名字
    找一个属性 ,直接就可以找到这个属性的值
    找一个方法 ,找到的是这个方法的内存地址
    hasattr() 判断一个命名空间中有没有这个名字
    getattr() 从命名空间中获取这个名字对应的值

    类中的反射
      类可以获取类中的属性和方法

    class A:
        role = 'Person'
        def func(self):
            print('*'*self)
    
    ret = input('>>>')
    if hasattr(A,ret):
        print(getattr(A,ret))
    

    执行输出:

    >>>func
    <function A.func at 0x00000206EFDFAA60>

    将点改成逗号,将右边的属性名/方法名,换成字符串,比如'role'
    整体就是A,'role'

    再通过getattr就可以获取了。

    class A:
        role = 'Person'
        def func(self):
            print('*'*self)
    
    ret = input('>>>')  # 假设输入的是func
    if hasattr(A,ret):
        func = getattr(A,ret)  # 此时func就是A类的func方法
        func(1)
    

    执行输出:

    >>>func
    *

    看这一句代码:

    func = getattr(A,ret)

     等式计算右边的,getattr获取的值为A类func方法的内存地址。那么将值赋予给func之后,

    外部的func和类内部的func名字是同名的,此时左边的fun和A类的方法名重名。但是不冲突,为什呢?因为一个在类外部有,一个在类的外表不

    加打印

    class A:
        role = 'Person'
        def func(self):
            print('*'*self)
    
    ret = input('>>>')
    if hasattr(A,ret):
        func = getattr(A,ret)
        print(func)
        func(1)
        print(func)
    

    查看内存地址:

    >>>func
    <function A.func at 0x000001E9CF8CAA60>
    *
    <function A.func at 0x000001E9CF8CAA60>
    

    内存地址是一样的

    小练习,使用反射的知识,用对象调用func

    class A:
        role = 'Person'
        def func(self):
            print('*'*10)
    
    a = A()
    

    答案:

    class A:
        role = 'Person'
        def func(self):
            print('*'*10)
    
    a = A()
    print(a.func)  # 获取a对象的func方法的内存地址
    if hasattr(a,'func'):
        getattr(a,'func')() # 执行func方法
    

    执行输出:

    <bound method A.func of <__main__.A object at 0x000002A0AD61BB00>>
    **********

    讲一个QQ的例子:

    qq客户端登录的时候,输入用户名和密码,将数据通过网络传输给腾讯服务器

    数据经过编码的,二进制数据。腾讯服务器接收到数据之后,解码得到字符串

    通过判断方法,来执行相应动作。

    假设有500种功能呢?写500层if判断?太low了

    有没有更好的办法呢?用反射

    在A类里面,定义好所有的方法

    用一个if判断,就可以执行对应的方法了。

    class A:
        role = 'Person'
        def __init__(self):
            self.money = 500
        def func(self):
            print('*'*10)
    a = A()
    print(a.func)
    if hasattr(a,'func'):
        getattr(a,'func')()
    'money' #使用字符串
    if hasattr(a,'money'):
        print(getattr(a,'money'))
    

    执行输出:

    <bound method A.func of <__main__.A object at 0x000001FC2D34FF28>>
    **********
    500

    类使用类命名空间中的名字
    对象使用对象能用的方法和属性
    模块使用模块中的名字
    import os ; getattr(os,'rename')('user','user_info')
    从自己所在的模块中使用自己名字

    import time  # 一个py文件就是一个模块
    time.time()
    if hasattr(time,'time'):
        print(time.time)
        print(getattr(time,'time')())

    执行输出:

    <built-in function time>
    1524044098.9708395

    新建文件teacher.py 内容如下:

    class Teacher:
        todo_list = [
    
        ]
        def __init__(self,name):
            self.name = name

    导入模块teacher

    import teacher
    t = 'Teracher'
    alex = teacher.t('alex').name
    print(alex)

    执行输出:alex

    import teacher
    t = 'Teacher'
    Terach_class = getattr(teacher,t)
    print(Terach_class)
    print(teacher.Teacher) 

    执行输出:

    <class 'teacher.Teacher'>
    <class 'teacher.Teacher'>

    假设有一个文件名userinfo,需要重命名

    第一种:常规办法

    import os
    os.rename('userinfo','user')
    

    第二种:使用反射

    import os
    #os.rename('userinfo','user') getattr(os,'rename')('user','user_info')
    a = 1
    b = 2
    def login():
        print('执行login功能')
    def register():
        print('执行register功能')
    func = input('>>>')
    

    怎么反射自己的模块名?

    使用sys模块,和python解释器相关的内容都在sys里

    import sys
    print(sys.modules['__main__'])  # 查看当前文件路径,包含文件名
    

    完整代码如下:

    def login():
        print('执行login功能')
    def register():
        print('执行register功能')
    import sys
    #print(sys.modules['__main__'])  # 找到自己所在的模块(py文件)
    func = input('>>>')
    getattr(sys.modules['__main__'],'login')()
    

    执行输出:

    >>>login
    执行login功能

    总结:

    类使用类命名空间中的名字
      getattr(类名,'名字')
    对象使用对象能用的方法和属性
      getattr(对象名,'名字')
    模块使用模块中的名字
      导入模块
      getattr(模块名,'名字')
      import os ; getattr(os,'rename')('user','user_info')
    从自己所在的模块中使用自己名字
      import sys
      getattr(sys.modules['__main__'],名字)

    getattr一定要和hasattr配合使用

    setattr

    class A:
        def __init__(self,name):
            self.name = name
        def wahaha(self):
            print('wahaha')
    a = A('alex')
    a.name
    a.wahaha()
    

    可以给a实例,绑定一个属性age

    class A:
        def __init__(self,name):
            self.name = name
        def wahaha(self):
            print('wahaha')
    a = A('alex')
    print(a.__dict__)
    setattr(a,'age',18)  # 给a对象新增一个属性
    print(a.__dict__)
    

    执行输出:

    {'name': 'alex'}
    {'name': 'alex', 'age': 18}

    再增加一个属性

    class A:
        def __init__(self,name):
            self.name = name
        def wahaha(self):
            print('wahaha')
    a = A('alex')
    print(a.__dict__)
    setattr(a,'age',18)  # 给a增加一个属性
    print(a.__dict__)
    setattr(a,'name','egon')  # 修改name属性
    print(a.__dict__)
    

    执行输出:

    {'name': 'alex'}
    {'name': 'alex', 'age': 18}
    {'name': 'egon', 'age': 18}

    删除一个属性

    class A:
        def __init__(self,name):
            self.name = name
        def wahaha(self):
            print('wahaha')
    a = A('alex')
    delattr(a,'name')
    print(a.__dict__)
    

    执行输出:{}

    很少有删除一个方法的
    上面都是倒腾属性的,
    下面说增删改方法,非常非常不常用

    class A:
        def __init__(self,name):
            self.name = name
        def wahaha(self):
            print('wahaha')
    
    def qqxing(self):
        print('qqxing')
    a = A('alex')
    setattr(a,'qqxing',qqxing)  # 增加一个属性
    print(a.__dict__)
    a.qqxing

    执行输出:

    {'name': 'alex', 'qqxing': <function qqxing at 0x00000216743F7F28>}

    不能set给对象添加一个方法
    否则a.qqxing()就报错
    这样才行

    class A:
        def __init__(self,name):
            self.name = name
        def wahaha(self):
            print('wahaha')
    
    def qqxing(self):
        print('qqxing')
    a = A('alex')
    setattr(a,'qqxing',qqxing)  # 增加一个属性
    # print(a.__dict__)
    a.qqxing(a)
    

    执行输出:qqxing

    面试也不会问 set方法
    方法可以绑定给类
    但是不能绑定给对象

    重点记住:

    getattr

    hasattr

    getatter和hasattr一般是成对出现,先判断,使用hasattr,再getatter

    实例化一个list

    li = list([1,2,3,4,5])
    print(li)
    

    li是对象,list是类

    查看长度,使用len方法

    li = list([1,2,3,4,5])
    print(li)
    print(len(li))
    

    执行输出:

    [1, 2, 3, 4, 5]
    5

    那么类,可以使用len方法吗?

    class A:
        def __init__(self,name,age,sex,cls):
            self.name = name
            self.age = age
            self.sex = sex
            self.cls = cls
    a = A('alex',81,'不详',2)
    print(len(a))
    

    执行输出:

    TypeError: object of type 'A' has no len()

    那么非要计算长度呢?

    有一个内置函数__len__和内置方法len()是唯一对应的关系

    当一个对象拥有__len__方法时,就可以使用len()方法时。

    class A:
        def __init__(self,name,age,sex,cls):
            self.name = name
            self.age = age
            self.sex = sex
            self.cls = cls
    
        def __len__(self):  # 添加__len__方法
            return 5
        
    a = A('alex',81,'不详',2)
    print(len(a))
    

    执行输出:

    5

    多实例化几次呢?

    class A:
        def __init__(self,name,age,sex,cls):
            self.name = name
            self.age = age
            self.sex = sex
            self.cls = cls
    
        def __len__(self):  # 添加__len__方法
            return 5
    
    a1 = A('alex',81,'不详',2)
    a2 = A('egon',20,'不详',3)
    a3 = A('yuan',21,'不详',4)
    print(len(a1))
    print(len(a2))
    print(len(a3))
    

    执行输出:

    5

    5

    5

    现在想要__len__有实际意义
    统计属性的个数

    class A:
        def __init__(self,name,age,sex,cls):
            self.name = name
            self.age = age
            self.sex = sex
            self.cls = cls
    
        def __len__(self):  # 添加__len__方法
            return len(self.__dict__)  # 通过__dict__方法,可以查看对象的属性
    
    a1 = A('alex',81,'不详',2)
    a1.hobby = '烫头'
    a2 = A('egon',20,'不详',3)
    a3 = A('yuan',21,'不详',4)
    print(len(a1))
    print(len(a2))
    print(len(a3))
    

    执行输出:

    5
    4
    4

    内置的东西,都和内置的方法有着千丝万缕的联系

    可哈希和不可哈希
    字典的寻址速度是最快的
    它用的是哈希算法

    在一次python程序运行的过程中,对同一个字符串进行运算之后,会得到一个数字
    字典的key不能一样

    一个对象,能不能hash

    靠一个内置方法__hash__决定的

    class A:
        def __init__(self,name,age,sex,cls):
            self.name = name
            self.age = age
            self.sex = sex
            self.cls = cls
    
    a1 = A('alex',81,'不详',2)
    print(hash(a1))
    

    执行输出:

    141908978608

    a1这个对象,为什么可以被hash呢?

    先看一下object源码,它包含了__hash__方法

        def __hash__(self, *args, **kwargs): # real signature unknown
            """ Return hash(self). """
            pass
    

    由于python3所有类都继承了object类,所以a1对象之所以可以hash,是靠object类来完成的。

    可以自己定义个__hash__方法

    class A:
        def __init__(self,name,age,sex,cls):
            self.name = name
            self.age = age
            self.sex = sex
            self.cls = cls
    
        def __hash__(self):
            return 0
    
    a1 = A('alex',81,'不详',2)
    print(hash(a1))
    

    执行输出: 0

    明日默写:

    class A:
        role = 'Person'
        def __init__(self):
            self.money = 500
        def func(self):
            print('*'*10)
    
    a = A()
    print(a.func)
    getattr(a,'func')()
    print(getattr(a,'money'))
    

    还有一个

    def login():
        print('执行login功能')
    
    def register():
        print('执行register功能')
    
    import sys  # 和python解释器相关的内容都在sys里
    print(sys.modules['__main__'])
    func = input('>>>')
    if hasattr(sys.modules['__main__'],func):
        getattr(sys.modules['__main__'],func)()
    

     

  • 相关阅读:
    搜索复习-中级水题
    搜索复习-基础水题(一共12道)
    TCPThree_C杯 Day1
    bzoj1579 道路升级
    bzoj3732 Network(NOIP2013 货车运输)
    bzoj1624 寻宝之路
    bzoj1430 小猴打架
    bzoj2763 飞行路线
    2017-10-28-afternoon-清北模拟赛
    2017-10-28-morning-清北模拟赛
  • 原文地址:https://www.cnblogs.com/xiao987334176/p/8875356.html
Copyright © 2011-2022 走看看