1 继承简介

继承
1 让类与类之间产生了关系 有了这层关系才有我们后续要说的多态
2 提高了代码的复用性
在创建类的时候 如果省略了父类 则默认父类为object
object  是所有类的父类class Person():   name = ''    # 军人与医生共有的属性age = ''class Doctor():name=''age=''def study(self):print('治病救人...')class soldier():name=''age=''def study(self):print('保卫国家...')

●继承是面向对象三大特性之一
●通过继承我们可以使一个类获取到其他类中的属性和方法
●在定义类时，可以在类名后面的括号中指定当前类的父类(超类、基类)
●继承提供了类的复用性。让类与类之间产生了关系。有了这个关系，才有了
多态的特性

#这是一个动物类
class Animal():def sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')a=Animal()a.sleep()动物会睡觉...

#我们想定义一个狗类
#定义一个思路 直接在动物类上面修改 再添加上狗独有的功能
#这样修改起来会比较麻烦 会违反了ocp原则

#第二种思路 创建一个新的类（狗类）
#创建一个新的类比较麻烦 会出现大量的复制粘贴

#三种思路 直接从Animal 类中继承它的属性和方法
#继承是面向对象的三大特征之一
#在定义类的时候 可以在类名后的括号中指定当前类的父类(超类 基类)

#这是一个动物类
class Animal():def sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')# 狗看家的方法class Dog():def sleep(self):print('狗会睡觉...')def run(self):print('狗会跑...')def speak(self):print('汪汪汪...')#我们想定义一个狗类
#定义一个思路  直接在动物类上面修改 再添加上狗独有的功能
#这样修改起来会比较麻烦 会违反了ocp原则#第二种思路   创建一个新的类（狗类）
#创建一个新的类比较麻烦  会出现大量的复制粘贴#三种思路  直接从Animal 类中继承它的属性和方法
#继承是面向对象的三大特征之一
#在定义类的时候 可以在类名后的括号中指定当前类的父类(超类  基类)class Dog(Animal):passdef speak(self):print('汪汪汪...')d=Dog()d.run()
d.speak()

isinstance() 函数 及其一些补充

—描述
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
—语法
以下是 isinstance() 方法的语法:
isinstance(object, classinfo)
—参数
object – 实例对象。
classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
—返回值
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

父类(基类 超类)

例如：先定义一个类叫车，车有以下属性：车体大小、颜色、轮胎、方向盘、品牌、速度、排气量，由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。
如果某类B“继承”另某类A，就把这个B称为“A的子类或派生类（subclass）”，而把类A称为“B的父类”也可以称为“A是B的超类或基类（superclass）”。

class Animal():def sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')
class Dog(Animal):passdef speak(self):print('汪汪汪...')d=Dog()d.run()
d.speak()r=isinstance(d,Dog)#   r=isinstance(d,Animal)#   print(r)    	       
print(r)           #   True#Dog 继承了Animal d 是Dog(类) 的实例  也是Dog的父类Animal的实例动物会跑...
汪汪汪...
True

Dog 继承了Animal d 是Dog(类) 的实例 也是Dog的父类Animal的实例
issubclass
●检查一个类是不是另外一个类的子类

class Animal():def sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')
class Dog(Animal):passdef speak(self):print('汪汪汪...')d=Dog()#检查一个类是不是另外一个类的子类
# issubclass()
print(issubclass(Dog,Animal))#检查Dog是否为Animal 的子类True

在创建类的时候 如果省略了父类 则默认父类为object
object 是所有类的父类

class Animal():def sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')
class Dog(Animal):passdef speak(self):print('汪汪汪...')d=Dog()#检查一个类是不是另外一个类的子类
# issubclass()print(issubclass(Dog,object)) True

如果子类和父类 有同样的方法 先去找自己的 如果没有 再去父类里找 如果父类里也没有就会报错(就是找也得找自己最近的)

class Animal():def sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')
class Dog(Animal):passdef speak(self):print('汪汪汪...')def run(self):print('狗会跑...')
d=Dog()d.run()#如果子类和父类 有同样的方法 先去找自己的 如果没有 再去父类里找  如果父类里也没有就会报错(就是找也得找自己最近的)

2方法的重写

●如果在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用
子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)
●当我们调用一个对象的方法时：
—会优先去当前对象中寻找是否具有该方法，如果有则直接调用
—如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中
的方法
—如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依
然没有找到就报错了

class A(object):def test(self):print('A....')class B(A):passclass C(B):passc=C() #创建一个C的实例c.test()A....

class A(object):def test(self):print('A....')class B(A):def test(self):print('B....')class C(B):passc=C() #创建一个C的实例c.test()B....

3super（）用法

super()可以获取当前类的父类
并且通过super()返回对象调用父类方法时，不需要传递self

class Animal():def __init__(self,name):self._name=namedef sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')@propertydef name(self):return self._name@name.setterdef name(self,name):self._name=name#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法class Dog(Animal):passdef speak(self):print('汪汪汪...')def run(self):print('狗会跑...')
d=Dog()d.run()TypeError: __init__() missing 1 required positional argument: 'name'
#TypeError:“name”缺少1个必需的位置参数

class Animal():def __init__(self,name):self._name=namedef sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')@propertydef name(self):return self._name@name.setterdef name(self,name):self._name=name#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法class Dog(Animal):passdef speak(self):print('汪汪汪...')def run(self):print('狗会跑...')
d=Dog('大秋田')print(d.name)大秋田

class Animal():def __init__(self,name):self._name=namedef sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')@propertydef name(self):return self._name@name.setterdef name(self,name):self._name=name#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法class Dog(Animal):passdef speak(self):print('汪汪汪...')def run(self):print('狗会跑...')
d=Dog('大秋田')d.name='黑色小天'
print(d.name)黑色小天

class Animal():def __init__(self,name):self._name=namedef sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')@propertydef name(self):return self._name@name.setterdef name(self,name):self._name=name#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法class Dog(Animal):def __init__(self,name,age):   #就是Dog的 父类Animal的__init__(self,name)中  如果还有 sex  weight height 我们还得 一个一个加 否则 d.sex='男'  只是单纯的赋值而已self._name=nameself._age=age@propertydef age(self):return self._age@age.setterdef age(self, age):self._age = agedef speak(self):print('汪汪汪...')def run(self):print('狗会跑...')
d=Dog('大秋田')d.name='黑色小天'
print(d.name)TypeError: __init__() missing 1 required positional argument: 'age'
#TypeError:“age”缺少1个必需的位置参数

class Animal():def __init__(self,name):self._name=namedef sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')@propertydef name(self):return self._name@name.setterdef name(self,name):self._name=name#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法class Dog(Animal):def __init__(self,name,age):# self._name = name#希望可以直接调用父类的initAnimal.__init__(self,name)   # 说明这个Animal.__init__(self,name)的操作 与上面的 self._name = name 作用一样 若是注释 它   用self._name = name  结果都是一样的 self._age=age@propertydef age(self):return self._age@age.setterdef age(self, age):self._age = agedef speak(self):print('汪汪汪...')def run(self):print('狗会跑...')
d=Dog('大秋田',5)d.name='黑色小天'
print(d.name,d.age)

当然如果有一天狗的父类变成了犬科 犬科的父类还是动物 这样更加细化 但是我们的Animal.init 就写死了 狗---->犬 ---->动物
所以我们希望有一种动态的获取父类的方式

class Animal():def __init__(self,name):self._name=namedef sleep(self):print('动物会睡觉...')def run(self):print('动物会跑...')@propertydef name(self):return self._name@name.setterdef name(self,name):self._name=name#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法  当然如果有一天狗的父类变成了犬科 犬科的父类还是动物 这样更加细化 但是我们的Animal.__init__  就写死了class Dog(Animal):def __init__(self,name,age):# self._name = name#希望可以直接调用父类的init# Animal.__init__(self,name)#super() 可以用来获取当前类的父类#通过super()不需要传递selfsuper().__init__(name)   # 这样写后结果扔是不变的 就如果有一天狗的父类变成了犬科  那么这样写会获得犬科 这样没写死self._age=age@propertydef age(self):return self._age@age.setterdef age(self, age):self._age = agedef speak(self):print('汪汪汪...')def run(self):print('狗会跑...')
d=Dog('大秋田',5)d.name='黑色小天'
print(d.name,d.age)黑色小天 5

class A:def add(self, x):y = x + 1print(y)class B(A):def add(self, x):super().add(x)b = B()
b.add(2)3

4多重继承

●在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类
●可以在类名的()后边添加多个类，来实现多重继承
●多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
●在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
●如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个…前面会覆盖后面的

#在python 中支持多继承的  也就是我们可以为一个类指定多个父类class A(object):def test(self):print('A....')class B(object):def test(self):print('B....')class C(A,B): #每个父类与父类之间用逗号隔开pass#类名.__bases__   这个属性可以获取当前类的所有父类
print(C.__bases__)(<class '__main__.A'>, <class '__main__.B'>)  #C有两个父类

在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂

#在python 中支持多继承的  也就是我们可以为一个类指定多个父类class A(object):def test1(self):print('A....')class B(object):def test2(self):print('B....')class C(A,B): #每个父类与父类之间用逗号隔开pass#类名.__bases__   这个属性可以获取当前类的所有父类c=C()c.test1()
c.test2()A....
B....

例例1

#在python 中支持多继承的  也就是我们可以为一个类指定多个父类class A(object):def test1(self):print('A....')class B(object):def test1(self):print('B中test1的方法')def test2(self):print('B....')class C(A,B): #每个父类与父类之间用逗号隔开pass#类名.__bases__   这个属性可以获取当前类的所有父类c=C()c.test1()

例例2

#在python 中支持多继承的  也就是我们可以为一个类指定多个父类class A(object):# def test1(self):#     print('A....')passclass B(object):def test1(self):print('B中test1的方法')def test2(self):print('B....')class C(A,B): #每个父类与父类之间用逗号隔开pass#类名.__bases__   这个属性可以获取当前类的所有父类c=C()c.test1()B中test1的方法

从例例1 和例例2 我们可以得出
#如果多个父类中出现同名的方法 则会先会在第一个父类中 寻找 然后是第二个依次类推

d=D( ) 我们来个d.test 就发现D的爹(父类)太多 会是很麻烦的 所以在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂

多态的简介

●多态是面向对象的三大特性之一。从字面理解就是多种形态
●一个对象可以以不同形态去呈现
●面向对象三大特性
----封装 确保对象中数据的安全
----继承 保证了对象的扩展性
----多态 保证了程序的灵活性

#多态是面向对象的三大特征之一
#一个对象也是可以有不同的形态去呈现class A(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = nameclass B(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = namea=A('葫芦娃')b=B('钢铁侠')#定义一个函数def speak(obj):print('好好复习%s'%obj.name)
speak(a)好好复习葫芦娃

class A(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = nameclass B(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = namea=A('葫芦娃')b=B('钢铁侠')class C:pass
c=C()#定义一个函数def speak(obj):print('好好复习%s'%obj.name)
speak(c)AttributeError: 'C' object has no attribute 'name'
“C”对象没有属性“name”

class A(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = nameclass B(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = namea=A('葫芦娃')b=B('钢铁侠')class C:pass
c=C()#定义一个函数def speak(obj):print('好好复习%s'%obj.name)
# speak(c)def speak2(obj):#做一个类型检查  检查一个对象是否是另一个类(类也是对象)的实例#这样写你当前的函数只适用于A类型的对象 if isinstance(obj,A):print('好好复习%s'%obj.name)speak2(a)  #如果传 speak2(b)  则没有结果好好复习葫芦娃

len() 通过对len()函数的说明 len()函数的用法就是多态类型的一种体验

#len()  通过对len()函数的说明  len()函数的用法就是多态类型的一种体验
#拓展
#len()函数之所以可以获取长度 是因为对象中有一个特殊方法__len__
#len() 检查一个序列的长度 或者检查这个序列有几个元素lst=[1,2,3,4,5,6,7]  #lst对象的类型是list
print(len(lst))
s='python'  #str
print(len(s))7
6

多态 只要你满足一个或者几个条件 一能作为参数去传递

class A(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = nameclass B(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = namea=A('葫芦娃')b=B('钢铁侠')
print(len(b))TypeError: object of type 'B' has no len()

class A(object):def __init__(self,name):self._name=name#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = nameclass B(object):def __init__(self,name):self._name=namedef __len__(self): ##################逻辑简写return 100#getter and setter@propertydef name(self):return self._name@name.setterdef name(self, name):self._name = namea=A('葫芦娃')b=B('钢铁侠')
print(len(b))100