@property、关联关系、继承、多继承

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
'''