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):
pass
def 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):
pass
def 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):
pass
def 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):
pass
def speak(self):
print('汪汪汪...')
d=Dog()
#检查一个类是不是另外一个类的子类
# issubclass()
print(issubclass(Dog,object))
True
如果子类和父类 有同样的方法 先去找自己的 如果没有 再去父类里找 如果父类里也没有就会报错(就是找也得找自己最近的)
class Animal():
def sleep(self):
print('动物会睡觉...')
def run(self):
print('动物会跑...')
class Dog(Animal):
pass
def speak(self):
print('汪汪汪...')
def run(self):
print('狗会跑...')
d=Dog()
d.run()
#如果子类和父类 有同样的方法 先去找自己的 如果没有 再去父类里找 如果父类里也没有就会报错(就是找也得找自己最近的)
2方法的重写
●如果在子类中有和父类同名的方法,则通过子类实例去调用方法时,会调用
子类的方法而不是父类的方法,这个特点我们称之为方法的重写(覆盖)
●当我们调用一个对象的方法时:
—会优先去当前对象中寻找是否具有该方法,如果有则直接调用
—如果没有,则去当前对象的父类中寻找,如果父类中有则直接调用父类中
的方法
—如果没有,则去父类中的父类寻找,以此类推,直到找到object,如果依
然没有找到就报错了
class A(object):
def test(self):
print('A....')
class B(A):
pass
class C(B):
pass
c=C() #创建一个C的实例
c.test()
A....
class A(object):
def test(self):
print('A....')
class B(A):
def test(self):
print('B....')
class C(B):
pass
c=C() #创建一个C的实例
c.test()
B....
3super()用法
super()可以动态获取当前类的父类
并且通过super()返回对象调用父类方法时,不需要传递self
class Animal():
def __init__(self,name):
self._name=name
def sleep(self):
print('动物会睡觉...')
def run(self):
print('动物会跑...')
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name=name
#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法
class Dog(Animal):
pass
def 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=name
def sleep(self):
print('动物会睡觉...')
def run(self):
print('动物会跑...')
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name=name
#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法
class Dog(Animal):
pass
def speak(self):
print('汪汪汪...')
def run(self):
print('狗会跑...')
d=Dog('大秋田')
print(d.name)
大秋田
class Animal():
def __init__(self,name):
self._name=name
def sleep(self):
print('动物会睡觉...')
def run(self):
print('动物会跑...')
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name=name
#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法
class Dog(Animal):
pass
def speak(self):
print('汪汪汪...')
def run(self):
print('狗会跑...')
d=Dog('大秋田')
d.name='黑色小天'
print(d.name)
黑色小天
class Animal():
def __init__(self,name):
self._name=name
def sleep(self):
print('动物会睡觉...')
def run(self):
print('动物会跑...')
@property
def name(self):
return self._name
@name.setter
def 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=name
self._age=age
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
def 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=name
def sleep(self):
print('动物会睡觉...')
def run(self):
print('动物会跑...')
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name=name
#狗类继承了动物类
#父类中所有的方法都会被继承 包括特殊方法
class Dog(Animal):
def __init__(self,name,age):
# self._name = name
#希望可以直接调用父类的init
Animal.__init__(self,name) # 说明这个Animal.__init__(self,name)的操作 与上面的 self._name = name 作用一样 若是注释 它 用self._name = name 结果都是一样的
self._age=age
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
def 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=name
def sleep(self):
print('动物会睡觉...')
def run(self):
print('动物会跑...')
@property
def name(self):
return self._name
@name.setter
def 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()不需要传递self
super().__init__(name) #是这里不需要传递self # 这样写后结果扔是不变的 就如果有一天狗的父类变成了犬科 那么这样写会获得犬科 这样没写死
self._age=age
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
def 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 + 1
print(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....')
pass
class 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的爹(父类)太多 会是很麻烦的 所以在开发中没有特殊情况,应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
多态的简介
●多态是面向对象的三大特性之一。从字面理解就是多种形态
●一个对象可以以不同形态去呈现(多态参考len( )函数的用法 len( )函数可以处理不同类型的对象 这个特征就是多态)
●面向对象三大特性
----封装 确保对象中数据的安全
----继承 保证了对象的扩展性
----多态 保证了程序的灵活性
#多态是面向对象的三大特征之一
#一个对象也是可以有不同的形态去呈现
class A(object):
def __init__(self,name):
self._name=name
#getter and setter
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class B(object):
def __init__(self,name):
self._name=name
#getter and setter
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
a=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
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class B(object):
def __init__(self,name):
self._name=name
#getter and setter
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
a=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
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class B(object):
def __init__(self,name):
self._name=name
#getter and setter
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
a=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
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class B(object):
def __init__(self,name):
self._name=name
#getter and setter
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
a=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
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class B(object):
def __init__(self,name):
self._name=name
def __len__(self): #################
#逻辑简写
return 100
#getter and setter
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
a=A('葫芦娃')
b=B('钢铁侠')
print(len(b))
100