day17 isinstance type issubclass 反射

1. issubclass,type,isinstance
  1.issubclass 判断xxx是否yyy的子类
    例:
    class Foo:
    　　pass
    class Bar(Foo):
   　　 pass
    class Base(Bar):
   　　 pass
    print(issbuclass(Bar,Foo))  #TRUE
    print(issubclass(Base,Foo)) #TRUE  可以进行隔代判断
    print(issubclass(Foo,Bar))  #FALSE 

    print(issubclass(Foo, object))  #TRUE
    print(issubclass(Bar, object))   #TRUE
    print(issubclass(BASE, object))   #TRUE object是所有类的根,是面向  对象的祖宗
    
    from collections import Iterator
    lst = []
    it = lst.__iter__() # list_iterator
    print(isinstance(it, Iterator)) # True

    
  2.type  帮我们判断xx数据是xxx书库类型的
   例:在计算时候判断数据类型是否可以进行计算
   def cul(a,b):      #传入两个数a和b,计算他们的和
     if(type(a)==int or type(a)==float) and (type(b)==int or type(b)==float):
          return a +b
     else:
         return "笨蛋,文字和数字分不清"

 3.isinstance 也是判断xx数据是yyy类型的,但是没有type那么精准
      class Base:
        pass
    class Foo(Base):
        pass
    class Bar(Foo):
        pass
    print(isinstance(Foo(), Foo)) # True
    print(isinstance(Foo(), Base)) # True
    print(isinstance(Foo(), Bar)) # False
    注:isinstance可以判断xx是xx家族体系的,但是只能往上(父类)判断,不能往下判断(子类)

2. 判断函数还是方法
  例
   class Foo:
    def chi(self):
        print("我是吃")
    @staticmethod
    def static_method():
    pass
    @classmethod
    def class_method(cls):
    pass
    f = Foo()
    print(f.chi) # <bound method Foo.chi of <__main__.Foo object at0x10f688550>>
    print(Foo.chi) # <function Foo.chi at 0x10e24a488>
    
    print(Foo.static_method) # <function Foo.static_method at 0x10b5fe620>
    print(f.static_method) # <function Foo.static_method at 0x10e1c0620>
    
    print(Foo.class_method) # bound method Foo.class_method of <class'__main__.Foo'>>
    print(f.class_method) #<bound method Foo.class_method of <class'__main__.Foo'>>

  结论:
   1.实例函数
     1.用类名访问是函数
     2.用对象访问是方法
    2.静态方法
     1.不管是用对象访问还是类名访问,都是函数
    3.类方法
     1.不管用对象访问还是类名访问,都是方法
     
    如何用程序判断是函数还是方法
    from types import FunctionType,MethodType
    def func():
        pass
    print(isinstance(func, FunctionType)) # True
    print(isinstance(func, MethodType)) # False

    class Foo:
        def chi(self):
            print("我是吃")
        @staticmethod
        def static_method():
            pass
        @classmethod
        def class_method(cls):
                pass
        obj = Foo()
        print(type(obj.chi)) # method
        print(type(Foo.chi)) # function
        print(isinstance(obj.chi, MethodType)) # True
        print(isinstance(Foo.chi, FunctionType)) # True
        print(isinstance(Foo.static_method, FunctionType)) # True
        print(isinstance(Foo.static_method, MethodType)) # False
        print(isinstance(Foo.class_method, FunctionType)) # False
        print(isinstance(Foo.class_method, MethodType)) # True

3. 反射:手动输入要运行的功能. 反着去模块里找. 这个就叫反射
    例 :
    impor master #导入模块
    from types import FunctionType       #导入函数模块
    while 1:
        gongneng=input("请输入你要测试的功能")
        if hasattr(master,gongneng):           #判断是否存在这个功能
            fn=getattr(master,gongneng)        #获取这个功能
            if isinstance(fn,FunctionType)       判断是否函数                        
                fn()                             #是函数就运行运行这个功能
            else:                                #不是就打印
                print("fn")

    class Car:
    def __init__(self,color,pai,price):
        self.color=color
        self.pai=pai
        self.price=price
    def fly(self):
        print("我的车会飞")
    c=Car("红色","京34234",1111)
    c.fly()               #我的车会飞
    # delattr(Car,"fly")
    # c.fly()           #'Car' object has no attribute 'fly'
    #                   #方法被删掉了删除 删除方法只能通过类名
    setattr(Car,"fly",lambda self:print("我的天,我的车可以打飞机"))
    c.fly()                     #我的天,我的车可以打飞机

    # print(c.color)          #红色
    # setattr(c,"color","黄色")
    # print(c.color)            #黄色 设置成了黄色,要设置属性只能去找对象
    
    getattr(模块,字符串) 从对象中获取XX功能
           可以从模块中获取功能,也可以从对象获取功能
           因为在python中,一切皆为对象
    hasattr()用来判断xxx中是否包含了xxx功能
    setattr(obj, str, value) 把obj中的str成员设置成value. 注意. 这里的value可以是
        值, 也可以是函数或者算法
    delattr(obj, str) 把obj中的str成员删除掉
    这几个操作都是在内存里面进行的,并不会影响你的源代码

    简写:
    hasattr(对象, 属性(字符串))
    getattr(对象, 属性(字符串)) 从对象中获取到xxx属性

    setattr(对象, 属性, 值)
    delattr(对象, 属性) 从对象中删除xxx属性

4.MD5加密   不可逆加密
    import hashlib
    obj = hashlib.md5(加盐)
    obj.update(铭文的bytes)
    obj.hexdigest() 获取密文
    
    例
    import hashlib
    SALT = b"abcdefghijklmnjklsfdafjklsdjfklsjdak"
    def jiami(content):
        obj = hashlib.md5(SALT)
        obj.update(content.encode("utf-8"))
        return obj.hexdigest()
        
    注册
    username = input("请输入你的用户名:") 
    password = input("请输入你的密码:")
    password = jiami(password)
    
    登录
    username = input("请输入你的用户名:")
    password = input("请输入你的密码:")

    if uname == username and upwd == jiami(password):
        print("登录成功")
    else:
        print("失败")