一、has a
has a：一个类中使用了另外一个自定义的类。
二、类型
系统类型：str、int、float、list、dict、tuple、set
自定义类型：自定义的类
import random
# 声明了Road类
class Road:
def __init__(self,name,len):
self.name = name
self.len = len
# 声明了Car类
class Car:
def __init__(self,brand,speed):
self.brand = brand
self.speed = speed
def get_time(self,road):
ran_time = random.randint(1,10)
msg = '{}品牌的车在{}上以{}速度行驶{}小时'.format(self.brand,road.name,self.speed,ran_time)
print(msg)
def __str__(self):
return '{}品牌的，速度：{}'.format(self.brand,self.speed)
# 1、创建实例化对象
r = Road('长深高速',1200)
r.name = '广河高速'
audi = Car('奥迪',120)
print(audi)
# r和road指向同一空间
audi.get_time(r) # road要传对象
三、is a
is a：真正的继承。
'''
继承：
Student、Employee、Doctor---都属于同一个类别Person
相同代码---》代码冗余，可读性不好
将相同代码提取---》Person类
Student、Employee、Doctor ---》继承Person
eg：
class Student(Person):
pass
特点：
1、如果类中不定义__init__,调用父类super class 的__init__
2、如果类继承父类，也需要定义自己的__init__，就需要在当前类的__init__调用父类的__init__
3、如何调用父类__init__:
super().__init__(参数)
super(类名，对象).__init__(参数)
4、如果父类和子类都有同名类，默认搜索的原则，先找当前类，再去找父类
5、override：重写(覆盖)。父类提供的方法不能满足子类的需求，就需要在子类中定义一个同名的方法，这种行为称为重写
6、子类的方法也可以调用父类的方法：super().方法名(参数)
'''
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self):
print(self.name+'正在吃法...')
def run(self):
print(self.name+'正在跑步...')
#继承
class Student(Person):
def __init__(self,name,age,clazz):
print('====>student的init')
# 如何调用父类的__init__
# super()表示父类对象
super().__init__(name,age)
self.clazz = clazz
def study(self,course):
print('{}正在学习{}课程'.format(self.name,course))
def eat(self,food):
super().eat()
print(self.name+'正在吃饭...：狮子头盖饭'+food)
class Employee(Person):
def __init__(self,name,age,salary,manager):
super().__init__(name,age)
self.salary = salary
self.manager = manager
class Doctor(Person):
def __init__(self,name,age,patients):
super(Doctor,self).__init__(name,age)
self.patients = []
self.patients.append(patients)
s = Student('hh',19,'A班')
s.run()
s.study('python')
s.eat('hh')
e = Employee('tom',23,10000,'king')
e.run()
list = ['a','v','c']
d = Doctor('liuli',22,list)
d.run()
四、多继承与搜索顺序
# 多继承与搜索顺序
class Base:
def test(self):
print('--------Base--------')
class A(Base):
def test(self):
print('AAAAAAAAAAAA')
class B(Base):
def test(self):
print('BBBBBBBBBBBB')
class C(Base):
def test(self):
print('-------->CCCCCCCC')
class D(A,B,C):
pass
# c = C()
# c.test()
# c.test1()
# c.test2()
d = D()
d.test()
'''
python允许多继承，
def 子类(父类1,父类2,...)
pass
# 多继承经典类：python2经典类深度优先 python3新式类广度优先
'''
# 查看搜索顺序
import inspect
print(inspect.getmro(D))
print(D.__mro__)
print(D.mro())
# 多态 封装 继承 ------》面向对象
class Person:
def __init__(self,name):
self.name = name
def feed_pet(self,pet):# pet既可以接受cat，也可以接受dog，还可以接受tiger，这就是python的多态
if isinstance(pet,Pet): # --->判断obj是不是类的对象或者判断obj是不是该类子类的对象
print('{}喜欢养宠物：{},昵称是{}'.format(self.name,pet.nickname,pet.role))
else:
print('千万别养！')
class Pet:
role = 'Pet'
def __init__(self,nickname,age):
self.nickname = nickname
self.age = age
def show(self):
print('昵称：{}，年龄：{}'.format(self.nickname,self.age))
class Cat(Pet):
role = '猫'
def catch_mouse(self):
print('抓老鼠...')
class Dog(Pet):
role = '狗'
def wathc_house(self):
print('看家高手...')
class Tiger:
def eat(self):
print('太可怕了，可以吃人...')
cat = Cat('bo',2)
dog = Dog('bigy',2)
person = Person('hh')
tiger = Tiger()
person.feed_pet(cat)
person.feed_pet(tiger)
