一、昨日内容回顾
成员
1、变量
1、成员变量--最常见
1、写法：
变量前面加了self就是成员变量
这里的self表示当前对象
一般是在构造方法中定义
2、调用：
对象.成员变量
3、作用：
可以在类中的不同方法间使用
有点局部的意思（每个对象的成员变量可以不同）
2、类变量（静态变量）
1、写法
写在类中，方法外的变量
2、调用
类名.类变量
3、作用
全局的意思
注意点：
1、如果用对象.类变量，就相当于给对象新增了一个和类变量同名的成员变量
原来的类变量不会有任何变化
2、方法
1、成员方法--最常见
1、范围：
构造方法：
创建对象的时候，自动调用构造方法
普通方法
2、写法：
1、第一个参数是self，表示当前对象本身
3、调用
对象.成员方法
内部原理：类名.成员方法(对象名)
2、静态方法
1、写法
1、方法上面加上@staticmethod
2、参数没有self
2、调用
类名.静态方法
3、作用
把静态方法理解成类中的函数就可以
3、类方法
1、写法
1、类方法名字上面加上@classmethod
2、第一个参数是cls
2、调用
类名.类方法
3、作用
用于在类中创建对象，设计模式
3、属性
1、概念
通过方法的形式来表示一个属性信息（变量-名称）
2、引入原因-由来
1、成员变量或者数据库字段一般不保存人的年龄，而是保存人的生日
2、因为年龄的话，每年都会变化，生日是不会变化的，易于维护
3、根据出生日期计算年龄，做成一个成员方法的，但是年龄是一个名词属性
用方法-动作来计算，稍有点不妥
4、于是，就引入了属性
3、写法
1、成员方法的定义上面加上一行@property
4、调用
对象名.属性名--调属性
对象名.方法名()--调成员方法
4、私有
1、私有变量
1、写法
类中，变量名字前面加上双下划线__
2、调用
1、不能用对象进行调用
2、可以在类中的成员方法中使用
3、对象如何间接调用私有变量
1、把私有变量写在类中的成员方法中
2、对象通过调成员方法，从而间接调用私有变量
2、私有方法
1、写法
类中，成员方法名字前面加上双下划线__
2、调用
1、不能用对象进行调用
2、可以在类中的成员方法中使用
3、对象如何间接调私有方法
1、把私有方法的调用，写在类中的成员方法中
2、对象通过调成员方法，从而间接调用私有方法
3、注意点：
1、子类继承父类的时候，无法继承父类的私有变量和私有方法
二、今日主要内容
1、依赖关系
1、比较轻的关系
2、例子：
大象装冰箱
大象装高压锅--多态
你打车
3、写法
1、类2的对象作为参数传入到类1的成员方法中
2、在类1的成员方法中，通过类2的对象调类2的成员方法
2、关联关系（组合、聚合）
1、一对一
1、例子：男女朋友
2、写法
1、类2的对象作为参数传入到类1的成员方法中
2、在类1的成员方法体中，把类2的对象赋值给类1的成员变量
3、类1的成员变量就可以指代类2的对象了
4、可以通过类1的成员变量调类2的成员变量，或者类2的成员方法
2、一对多
1、例子：学校和老师
2、写法
类1-学校类的定义
1、类1-学校类中定义一个成员变量，赋值空列表
2、把类2的对象作为参数传入到类1的成员方法1中
3、在类1的成员方法体中，把类2的对象添加到空列表
4、在类1的成员方法2中，循环遍历这个列表，列表的每个元素就是类2的对象
通过类2的对象调类2的成员变量
类1的成员方法调用
1、类1的对象每调用一次成员方法1，就新增加一个老师对象到列表中
3、继承关系，实现关系
1、self：当前执行这个方法的对象
2、子类继承父类
1、新建的是子类对象，那么self就是子类对象
2、新建的是父类对象，那么self就是父类对象
4、特殊成员
1、重点是：
__str__() #打印对象，默认是打印对象的内存地址；
重写__str__（）后，打印对象的时候，可以打印对象的成员变量
例子：
def __str__(self):
# return self.name,self.age,self.hobby #报错
# TypeError: __str__ returned non-string (type tuple)
# 返回值必须是字符串，而不能是元组
return '%s %s %s' % (self.name,self.age,self.hobby)
__new__() #创建对象的过程
1、加载类
calss 类名 定义类
2、开辟内存空间
__new__(cls)方法，此时内存空间没有对象，需要下一步创建
3、创建对象
通过__new__(cls)的返回值
return object.__new__(cls) 来创建对象
注意点：这里参数是cls类，而不是self对象，因为此时只有类，对象还没有被创建出来
4、初始化对象
构造方法 __init__()
5、使用对象
对象调成员变量，或者对象调成员方法
2、常见特殊成员
1、__init__() 构造方法
2、__hash__()
类和对象默认是可哈希的，不可变，可以作为字典的key
__hash__ = None #就变成不可哈希，可变的，不能作为字典的key
3、__getitem__(value)
对象[key]就是调用__getitem__（value）方法，参数是value
通过key获取value，类似字典
4、__setitem__()
对象[key] = value 就是调用__setitem__（key,value）方法，参数是key,value
添加键值对，类似字典
5、__delitem__(key)
del 对象[key]就是调用__delitem__（key）方法，参数是key
通过key删除键值对，类似字典
6、__enter__()
return 字符串
7、__exit__()
with 对象 as 变量:
pass
print(变量)
过程如下:
1、先调__enter__()方法进入
2、其返回值，被with后面的变量接收
3、再调__exit__()方法退出
例子：打开文件
一、依赖关系
需求：要把大象装冰箱
伪代码思路：
1、新建2个类，大象类和冰箱类
2、关系：大象类要依赖冰箱类
3、大象类--成员方法：
1、开冰箱门--依赖冰箱类--传入冰箱对象
2、装自己
3、关冰箱门--依赖冰箱类
4、冰箱类--成员方法：
1、开门
2、关门
需求2：要把大象装高压锅 -这里的冰箱和高压锅 多态
伪代码思路：
1、新建2个类，大象类和高压锅类
2、关系：大象类要依赖高压锅类
3、大象类--成员方法：
1、开高压锅门--依赖高压锅类--传入高压锅对象
2、装自己
3、关高压锅门--依赖高压锅类
4、高压锅类--成员方法：
1、开门
2、关门
小结：
1、依赖是一种松耦合的关系
大象开冰箱门，冰箱坏了，大象还可以开高压锅门
2、多态思想
大象开冰箱门，开高压锅门 冰箱和高压锅对象就是多态
3、依赖的写法
1、类a依赖类b
大象类依赖冰箱类
2、类a的成员方法，形参是类b的对象
类a的成员方法的内容： 类b的对象.类b的成员方法()
4、依赖的概念
在方法中引入另一个类的对象
5、没有特指
大象开冰箱门，想要的对象是一个冰箱-泛指，
具体是哪个冰箱（是那台haier冰箱，还是这台美的冰箱）没有指定--没有特指（这台还是那台）
关联关系：一对一
1、在类1的成员方法中，把类2的对象作为形式参数，传递给类1的成员变量
self.类1的成员变量 = 类2的对象
左边就可以等价于右边（即类2的对象的地方，可以用类1的对象.成员变量表示
依赖关系和关系关系的区别
一、写法不同：
1、前者
在类1的成员方法中，把类2的对象作为形式参数
写法:
类1的成员方法(类2的对象)： #这里类2的对象可以是冰箱，也可以是高压锅，多态
类2的对象.类2的成员方法()
2、后者
在类1的成员方法中，把类2的对象作为形式参数,传递给类1的成员变量
写法:
类1的成员方法(类2的对象)：
self.成员变量=类2的对象
说明：后面凡是用到类2对象的地方，可以用类1对象.成员变量代替
二、例子
1、前者的例子是大象装冰箱，打车（今天打这个车，明天打那个车）
--（类比：关系比较轻，大象可以装不同的冰箱，你可以打不同的车）
后者的例子是男女朋友--（类比：关系更紧密）
关联关系中一对一和一对多的区别
一、写法不同
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、后者的例子是学校和老师
扩展：
组合关系、聚合关系和关联关系的写法是类似的
四、特殊成员
特殊成员
1、写法
双下划线开头，双下划线结尾的方法
2、作用
特殊场景下，会自动执行
3、例子
__init__()
一、构造方法
1、创建对象的时候，会自动执行构造方法 __init__()
二、__call__()方法
1、用法
新建对象()，就会自动调用__call__()方法
2、对象后面加小括号 对象()是python特有的
三、__getitem__()方法
1、用法
对象名[key],就会自动调用__getitem__(key)方法
参数就是key
2、类似字典，可以从对象中获取key
四、__setitem__()方法
1、用法
对象名[key]=value,就会自动调用__setitem__(key,value)方法
参数是key,value
2、类似字典，相当于给对象添加一个键值对
五、__delitem__()方法
1、用法
del 对象名[key],就会自动调用__delitem__(key)方法
参数是key
2、类似字典，相当于给对象删除一个键值对
六、__enter__()方法
return var1
__exit__()方法
with 对象 as 变量:
print var1 #这里的var1是__enter__方法的返回值
1、说明：
with的执行过程
1、先执行__enter__方法
2、再执行with中的代码块
3、最后执行__exit__方法
七、__hash__()方法
1、类名和对象名默认都是可哈希的，不可变的，可以作为字典的key
原因是：万事万物都是对象，类名是object的子类
object这个类中有__hash__（）方法
这个方法的存在，就表示可以哈希
2、__hash__ = None
在类中加上上面一行，类名就不可哈希，可变的，不能作为字典的key
注意点:这里是 =赋值 而不是==值的判断
八、__str__() 方法
1、__str__() 方法是Boy的父类object的方法，如果子类不重写的话
打印对象，就是打印对象的内存地址
2、子类重写__str__() 方法后
再次打印对象，就可以不输出对象的内存地址，而是自定义输出了
3、注意点：
__str__() 方法的返回值的类型必须是字符串，而不能是元组，否则会报错
九、__new__(cls)方法
创建对象的步骤
1、加载类
2、开辟内存空间：通过__new__(cls)方法
3、创建对象： 通过__new__(cls)方法的返回值
object.__new__(cls)来创建对象
注意点：__new__（）的参数是cls类，而不是对象（因为现在对象还没有创建出来）
4、初始化对象：
创建对象的过程中，自动调构造方法__init__()，初始化对象
把成员变量封装到对象中，就是初始化对象
5、使用对象：
1、打印对象
2、对象调成员方法
3、对象调成员变量
