1.@property使用来修饰属性的，将属性私有化改为公有化，但是可以设置属性条件
格式：
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
@property
def age(self):
return self.age
@age.setter
def age(self,age):
if age >0 and age <100:
self.age = age
else:
print('不属于正常范围！')
def __str__(self):
return '{}今年{}岁！'.format(self.name,self.age)
p = Person('张三',20)#创建对象
p.age = 25
p.__str__()#结果为张三今年25岁！
2.关联关系分为两种：一种是has a关系，另外一种是is a关系
3.has a关系是指一个类包含另外一种类，或者另外几种类
class Road:
def __init__(self,r_name,l):
self.r_name = r_name
self.l = l
class Car:
def __init__(self,c_name,speed):
self.c_name = c_name
self.speed = speed
def get_time(self,road):#调用Road类的对象，以及方法
t = road.l//self.speed
return '{}在{}行驶了{}小时'.format(self.c_name,road.r_name,t)
def __str__(self):
return '车名：{}，时速：{}'.format(self.c_name,self.speed)
r = Road('106国道',336)
c = Car('奥迪',100)
print(c.get_time())#结果为奥迪在106国道上面行驶了3小时
print(c.__str__())#结果为车名：奥迪 时速100
4.is a其实就是继承的关系，子类继承父类
格式子类名(父类名)：
class Person:
def __init__(self,num,name,salary):#初始化方法
self.num = num
self.name = name
self.salary = salary
def get_num(self):#获取工号方法
return self.num
def get_name(self):#获取年龄方法
return self.name
def set_name(self,name):#设置姓名方法
self.name = name
def get_salary(self):
return self.salary
def __str__(self):#查看员工的所有信息
return '工号为{}的员工{}，薪资为{}'.format(self.num,self.name,self.salary)
#定义子类Worker类
class Worker(Person):
def __init__(self,hours,h_salary)：
super().__init__()#调用父类的方法，通过super().方法名
self.hours = hours
self.h_salary = h_salary
def get_salary(self):#重写父类方法
salary += hours*h_salary
return self.salary
w = Worker(101，'张三',3000,200,15)
print(w.get_salary)#结果为6000#无需重写父类方法，可以共用
print(w.get_num())#结果,101
w.set_name('张小三')#无需重写父类方法，可以共用
print(w.__str__())#结果为员工号为101的员工张小三，薪资6000
#直接调用父类的__str__()
5.多继承：就是一个子类可以继承多个父类
python2使用的是经典类：深度优先
python3使用的是新式类：广度优先：从左至右，深度优先
#新式类
class P1(object):
def foo(self):
print('p1----->foo')
def bar(self):
print('p1----->bar')
class P2(object):
def foo(self):
print('p2----->foo')
def bar(self):
print('p2----->bar')
class C1(P1,P2):
pass
class C2(P1,P2):
def foo(self):
print('c2----->bar')
class D(C1,C2):
pass
d = D()
d.foo()#结果为p1----->foo
d.bar()#c2----->bar
'''解析：
1）D类对象继承C1，C2类，C1，C2类都继承P1，P2类，P1，P2类都继承
object类
2）当对象d在调用foo方法时，先去自身的类中寻找方法，发现没有，再去
由左到右的父类C1中去找，发现C1类中也并没有，就去父类C2中调用，发现没有该方法，就去C2父类P1中寻找发现有foo方法，故打印p1----->foo
3）当对象d在调用bar方法时，先去自身的类中寻找方法，发现没有，再去
由左到右的父类C1中去找，发现C1类中也并没有，就去父类C2中调用，发现有该方法，故打印C2----->bar
4）如果是经典类的话，在P1，P2类中没有父类object
它的继承调用是D类没有找C1类，C1类没有找C1父类P1类
如果在没有就找C2，P2，符经典类打印结果为p1----->foo,p1----->bar
'''
