Python【day 19】反射

''''''
'''
一、昨日内容回顾
1、依赖关系
    1、弱关系、多态
        1、松耦合
        2、大象可以装冰箱，也可以装高压锅，就是多态

    2、例子：
        1、大象装冰箱
        2、大象装高压锅
        3、你打车

    3、写法
       大象类中的普通方法的参数是冰箱对象
       大象类中的普通方法体是冰箱对象.冰箱的普通方法

2、关联关系
    1、一对一
        1、强关系
        2、例子
            1、男女朋友

        3、写法
            1、男孩类的普通方法的参数是女孩对象
            2、男孩类的普通方法体是
                self.girl_friend = girl
                #用self.girl_friend指代女孩对象

    2、一对多
        1、强关系
        2、例子
            1、学校和老师
        3、写法
           1、学校类的构造方法中，定义老师列表-空列表（可以定义私有变量）
           2、学校类的普通方法中-招聘（参数是老师对象）
              老师列表中追加老师对象
           3、学校类的普通方法-展示
              循环遍历老师的姓名

    3、一对一和一对多的区别
        一、写法不同
            1、前者
                男孩类的成员方法
                    def meet(self,girl):  #参数是女孩对象  女孩对象传递给男孩的女朋友这个成员变量
                        self.girl_friend = girl  #关键点
                        #男孩对象的成员变量-girl_friend就是女孩对象

            2、后者
            学校类的构造方法
                self.__techer_list = []
            学校类的成员方法
                def recruit(self,t):  #招聘-成员方法  参数t是老师对象
                    self.__techer_list.append(t)

        二、例子不同
            1、前者的例子是男女朋友
            2、后者的例子是学校和老师

3、特殊成员
   1、 __init__()
        #新建对象的时候，自动调构造方法

   2、 __str__()
        1、打印对象的时候，默认打印对象的内存地址
        2、如果在__str__()方法中，返回自定义的字符串，那么
           打印对象的时候，就不是内存地址，而是自定义的字符串
        3、注意点：
            __str__() 方法的返回值的类型必须是字符串，而不能是元组，否则会报错

   3、 __new__()
        创建对象的过程
        1、加载类

        2、开辟内存空间
           通过__new__(cls)方法

        3、创建对象
            通过__new__(cls)方法的返回值
                 return object.__new__(cls)来创建对象
                 注意点：__new__（）的参数是cls类，而不是对象
                       （因为现在对象还没有创建出来）

        4、初始化对象
            创建对象的时候，自动调构造方法
            把成员变量封装到对象中

        5、使用对象
            对象调成员方法、调成员变量

   4、 __call__()
       对象名后面加上小括号，就是调了__call__()方法

   5、 __enter__()
   6、 __exit__()
      __enter__()方法
        return var1
      __exit__()方法
    with 对象 as 变量:
        print var1   #这里的var1是__enter__方法的返回值
    1、说明：
        with的执行过程
        1、先执行__enter__方法
        2、再执行with中的代码块
        3、最后执行__exit__方法

   7、 __setitem__()
   8、 __delitem__()
   9、 __getitem__()
        def __getitem__(self, item):
            print('我是__getitem__方法',item)

        def __setitem__(self, key, value):
            print('我是__setitem__方法',key,value)

        def __delitem__(self, key):
            print('我是__delitem__方法',key)

        f1['name']  #我是__getitem__方法 name
        #这里调用的是__getitem__()方法

        f1['name'] = 'jack'  #我是__setitem__方法 name jack
        #这里调用的是__setitem__()方法

        del f1['name']  #我是__delitem__方法 name
        #这里调用的是__delitem__()方法

   10、 __hash__()
       1、类和对象都是可哈希的-不可变的，可以作为字典的key
          因为类都是object的子类，object类中有__hash__（）方法
       2、  __hash__ = None
           在类中加入上面一行，就是重写了其父类object的__hash__()方法
           类名和该类名对应的对象名就变成了不可哈希-可变的，不能作为字典的key了

二、今日主要内容
    1、 issubclass   type   isinstance
        issubclass(类名1,类名2)   #判断参数1是否是参数2的后代（子类，孙子类），是的话，返回True

        type 给出xxx的数据类型，给出创建这个对象的类

        isinstance 参数1-对象名 参数2-类名  判断对象是否是类及其子类的对象---重点1

    2、如何分辨方法和函数
             在外面定义的函数一定是函数
        在类中:
            1. 普通方法: 如果是对象访问.方法,, 如果是类名访问是函数
            2. 静态方法: 都是函数
            3. 类方法: 都是方法
            4、属性：是变量（不是函数，也不是方法）

        isinstance(args,MethodType)和isinstance(args,FunctionType)
        是用于判断函数的参数是方法还是函数类型
        参数可以是（普通方法名、静态方法名、类方法名、属性）

    3、反射--重点2
        1、重点
        getattr(对象名,函数名或者变量名)
            参数列表：参数1是对象或者类，参数2是要查找的函数名或者变量名
            作用：从对象中（对象或者类中）查找指定的内容
            使用：找到后将内存地址存在变量中，变量名后面加上小括号，就是调用函数
                ret1 = getattr(p1,'eat')  #或者函数eat的内存地址
                ret1() #函数的内存地址后面加上小括号

        hasattr(对象名,函数名或者变量名)
            参数列表：参数1是对象或者类，参数2是要查找的函数名或者变量名
            作用：判断对象中（对象或者类中）是否有你要查找的指定内容 和if
            使用：有的话，就接着使用getattr
                 没有的话，就提示没有你要找的指定内容
                 if hasattr(p1,'eat'):  #注意点：函数名加上引号
                    ret1 = getattr(p1,'eat')  #或者函数eat的内存地址
                    ret1() #函数的内存地址后面加上小括号
                 else:
                    print('你要查找的内容不存在')

        2、次重点 在内存层面修改，文件并没有修改
        setattr(对象名,变量名,变量值)
            参数列表：参数1是对象或者类，参数2是变量名，参数3是变量的值
            作用：给对象（对象或者类）的构造方法中，新增一个变量--内存层面，临时增加
            setattr(p1,'age',18)  #注意点：变量名要加上引号

        delattr(对象名,变量名)
            参数列表：参数1是对象、类、模块py文件，参数2是变量名
            作用：删除类中构造方法的一个变量--内存层面，临时删除
            delattr(p1,'age')   #注意点：变量名要加上引号
            delattr(p1,'name')  #从对象中删除变量（成员变量）
            delattr(Person,'eat')  #从类中删除函数eat
            delattr(master,'eat')  #从模块py文件中删除方法eat

前19天小结
1、基本数据结构
2、三大器（迭代器、生成器、装饰器）
3、面向对象
4、反射

'''