''''''

'''

一、昨日内容回顾

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、反射

'''