Python基础(十一) 类继承

类继承:

继承

Python 格式:

class 类名(父类名):

class Animal:
    def eat(self):
        print("-----吃----")
    def drink(self):
        print("-----喝----")
    def sleep(self):
        print("-----睡觉----")
    def run(self):
        print("-----跑----")

class Dog(Animal):
    def bark(self):
        print("----汪汪叫---")


class Xiaotq(Dog):
    def fly(self):
        print("----飞----")
    def bark(self):#重写父类方法
        print("----狂叫----")
        #第1种调用被重写的父类的方法
        #Dog.bark(self)#调用父类方法格式:类名.方法名(self)

        #第2种
        super().bark()


xiaotq = Xiaotq()
xiaotq.fly()
xiaotq.bark()
xiaotq.eat()

私有方法、属性不会被继承,所以子类不能调用父类的方法或属性

二十二. Python基础(22)–继承

#父类方法的重写
class AxFather(object):
    def makeMoney(self):
        print('今天挣了1000w')

class Ax(AxFather):
    def makeMoney(self):  #重写了父类的方法
        print('今天挣了2000w')
ax=Ax()
ax.makeMoney()

一、继承

继承的想法在于,充份利用已有类的功能,在其基础上来扩展来定义新的类。

多继承

格式:

class 类名(父类名1,父类名2,...):

class Base(object):
    def test(self):
        print("----Base")

class A(Base):
    def test1(self):
        print("-----test1")

class B(Base):
    def test2(self):
        print("-----test2")

class C(A,B):
    pass

c = C()
c.test1()
c.test2()
c.test()

● 知识框架

图片 1

继承是一种创建新的类的方式,在python中,新建的类可以继承自一个或者多个父类,原始类称为基类或超类,新建的类称为派生类或子类。

 

多继承扩展

class Base(object):
    def test(self):
        print("----Base")

class A(Base):
    def test(self):
        print("-----A")

class B(Base):
    def test(self):
        print("-----B")

class C(A,B):
    pass
    #def test(self):
    #    print("-----C")


c = C()
c.test()

print(C.__mro__)#此方法为类方法的调用顺序,为C3算法,如果C类没有改方法,就通过此方法依次往下寻找
C.__mro__打印结果:
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <type 'object'>)

2,父类方法的修改

python中类的继承分为:单继承和多继承

Parent Class(父类)
与 Child Class(子类):

 

class AxFather(object):
    def __init__(self,op):
        print('父类',op)

    def makeMoney(self):
        print('今天挣了1000w')

class Ax(AxFather):

    def __init__(self,op,code):
        # AxFather.__init__(self,op)#先调用一下父类的构造方法,有父类的功能
        #如果想修改父类的构造方法,那么你就先调用父类的方法
        super(Ax,self).__init__(op)#通上面的功能是一样的,写的方式不一样而已
        #super中传入本类,不是父类,super自动帮助本类找到父类
        print('这是Ax',op,code)

    def makeMoney(self):
        print('今天挣了2000w')

Ax('抽烟,喝酒','python')#实例化后,没保存
class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass1
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
    pass

被继承的类称为父类,继承的类称为子类,一个父类,可以有多个子类;

● 继承关系中self的指向

 

使用’__bases__’方法查看继承

子类,一旦继承父类,就拥有了父类的属性与方法,根据需要可以进行增删改。

当一个对象调用一个方法时,这个方法的self形参会指向这个对象

class A:

    def get(self):

        self.say()

 

    def say(self):

        print(‘AAAAA’)

 

class B(A):

    def say(self):

        print(‘BBBBB’)

 

b = B()

b.get() # BBBBB

# 当一个对象调用一个方法时,这个方法中的self就指向这个对象

# 子类先调用自己的属性或方法, 子类自己没有才调父类的

# 如果是class B(A):pass, 那么结果是’AAAAA’

print(dir(b))

# [‘__class__’, ‘__delattr__’, ‘__dict__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__init_subclass__’, ‘__le__’, ‘__lt__’, ‘__module__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’, ‘cls_att’, ‘get’, ‘name’, ‘say’]

print(b.__dict__)

# {‘name’: ‘Arroz’}

print(vars(b))

# {‘name’: ‘Arroz’}

print(b.__class__)

# <class ‘__main__.B’>

print(B.__class__)

#<class ‘type’> # 实例关系

print(B.__bases__)

# (<class ‘__main__.A’>,) # 继承关系

print(B.__doc__)

# This is class B

>>> SubClass1.__bases__
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

这种做法的主要好处之一就是代码重用。

 

提示:如果没有指定基类,python的类会默认继承object类,object是所有python类的基类,它提供了一些常见方法(如__str__)的实现。

 


经典类(old-style)和新式(new-style)类调用父类方法的区别

>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

示例代码1:

class Dog(Animal):

    def __init__(self, name):

        # Animal.__init__(self, name) # 经典类, 注意不要遗漏self

        super().__init__(name) # 新式类, 等价于super(Dog, self).__init__(name),读作"调用Dog的父类

         的方法(calling Dog’s parent’s method)"

内置函数super([type[, object-or-type]])

Return a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing inherited methods that have been overridden in a class. The search order is same as that used by getattr() except that the type itself is skipped.

二、继承与抽象(先抽象再继承)

#*_*coding:utf-8*_*

class perent_class(object):
    def __init__(self,name):
        self.name = name

    def printName(self):
        print('你的名字是:'+self.name)


class child_class(perent_class):
    def __init__(self,name,age):
        super(child_class,self).__init__(name) #初始化类super()函数返回类对象
        self.age = age


if __name__=="__main__":
    child_class('xzdylyh','25').printName()

 

抽象即抽取类似或者说比较像的部分。是一种归类的方法。

输出

● 综合案例

抽象分成两个层次: 

C:\Python27\python.exe D:/weixin/temp/temp.py
你的名字是:xzdylyh

Process finished with exit code 0

class Base:

    cls_attr = ‘class attribute’

    def __init__(self, name, age, job):

        self.name = name

        self.age = age

        self.job = job

    def bmeth(self):

        print(‘Base method’)

 

class Derived_0(Base):

    def dmeth(self):

        print(‘Derived method’)

 

print(type(Base)) # <class ‘type’>, 元类

print(type(Derived_0)) # <class ‘type’>, 元类

 

# 没有添加新的对象属性, 不用使用super()

d_0 = Derived_0(‘Paul’, 55, ‘Singer’)

print(d_0.job)

 

# 下面添加了添加了新的对象属性, 需要使用super()

class Derived_1(Base):

    def __init__(self, name, age, job, hobby):

        super(Derived_1, self).__init__(name, age,job) # ※ 子类调用父类方法时, 参数的个数不能缺少.

        self.hobby = hobby

    def dmeth(self):

        print(‘Derived method’)

    def show(self):

        print(self.name, self.age, self.job,self.hobby)

 

class Derived_2(Base):

    def __init__(self, name, hobby):

        super(Derived_2, self).__init__(name, 20, ‘teacher’) # 子类调用父类方法时, 参数的个数不能缺少, 并且可以把已知的属性先传给父类的构造函数

        self.hobby = hobby

    def dmeth(self):

        print(‘Derived method’)

    def show(self):

        print(self.name, self.age, self.job,self.hobby)

 

class Derived_3(Base):

    def __init__(self, hobby):

        super(Derived_3, self).__init__("Paul", 22, ‘painter’) # 子类调用父类方法时, 参数的个数不能缺少, 并且可以把已知的属性先传给父类的构造函数

        self.hobby = hobby

 

    def dmeth(self):

        print(‘Derived method’)

 

    def show(self):

        print(self.name, self.age, self.job, self.hobby)

 

#① #######################################################

b = Base(‘Arroz’, 18, ‘teacher’)

print(Base.__dict__) # 类的属性

”’

{‘__module__’: ‘__main__’, ‘cls_attr’: ‘class attribute’, ‘__init__’: <function Base.__init__ at 0x00000000028EA840>, ‘bmeth’: <function Base.bmeth at 0x00000000028EA8C8>,

‘__dict__’: <attribute ‘__dict__’ of ‘Base’ objects>, ‘__weakref__’: <attribute ‘__weakref__’ of ‘Base’ objects>, ‘__doc__’: None}

”’

print(b.__dict__) # 对象属性

”’

{‘name’: ‘Arroz’, ‘age’: 18, ‘job’: ‘teacher’}

”’

print(‘———————-‘)

#② #######################################################

d_1 = Derived_1(‘Arroz’, 18, ‘teacher’,’swimming’)

d_1.show() # Arroz 18 teacher swimming

print(‘———————-‘)

#③ #######################################################

d_2 = Derived_2(‘Pwter’, ‘skating’)

d_2.show() # Pwter 20 teacher skating

print(‘———————-‘)

#④ #######################################################

d_3 = Derived_3(‘jogging’)

d_3.show() # Paul 22 painter jogging

  1. 将奥巴马和梅西这俩对象比较像的部分抽取成类; 

  2. 将人,猪,狗这三个类比较像的部分抽取成父类。

 

 

抽象最主要的作用是划分类别(可以隔离关注点,降低复杂度)

当子类与父类下方法相同时,子类会覆盖父类的方法内容;其实这即是一种重写,也是一种多态。

图片 2

 

继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。

抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类。

图片 3

 

 三、 继承与重用性

在开发程序的过程中,如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时,我们不可能从头开始写一个类B,这就用到了类的继承的概念。

通过继承的方式新建类B,让B继承A,B会‘遗传’A的所有属性(数据属性和函数属性),实现代码重用。

class A:
    def test(self):
        print('test function')

class B(A):     #新建类B继承类A,类A中的属性全部被类B继承
    pass

b1 = B()    #类B的实例可引用父类B的'test'方法
b1.test()

#运行结果
#test function

用已经有的类建立一个新的类,这样就重用了已经有的软件中的一部分设置,大大减少了编程工作量,这就是常说的软件重用。不仅可以重用自己的类,也可以继承别人的,比如标准库,来定制新的数据类型,这样就大大缩短了软件开发周期,对大型软件开发来说,意义重大。

当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性(不会影响到父类),需要注意的是,一旦重新定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准了。

class A:
    def test(self):
        print('test function')

class B(A):     #新建类B继承类A,类A中的属性全部被类B继承
    def test(self):
        print('test function B')
    pass

b1 = B()    #类B的实例可引用父类B的'test'方法,但自身类下也有重名的’test‘方法,以自身优先
b1.test()

#运行结果
#test function B

 

在子类中,新建的重名的函数属性,在编辑函数内功能的时候,有可能需要重用父类中重名的那个函数功能,应该是用调用普通函数的方式,即:类名.func(),此时就与调用普通函数无异了,因此即便是self参数也要为其传值

class A:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def test(self):
        print('test function')

class B(A):     #新建类B继承类A,类A中的属性全部被类B继承

    pass

b1 = B('jack', 21)    #类B的实例可引用父类B的'test'方法
print(b1.name)
print(b1.age)
b1.test()

#运行结果
#jack
#21
#test function 

 

class A:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def test(self):
        print('test function')

class B(A):     #新建类B继承类A,类A中的属性全部被类B继承
    def __init__(self, name, age, country):
        A.__init__(self, name, age)     #引用父类的属性
        self.country = country          #增加自身独有的属性

    def test(self):
        print('test function B')
    pass

b1 = B('jack', 21, 'China')    #类B的实例可引用父类B的属性,如果有重名属性,以自身类的属性优先
print(b1.name)
print(b1.age)
print(b1.country)
b1.test()

#运行结果
#jack
#21
#China
#test function B

四、组合与重用性

组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合

class Teacher:
    def __init__(self, name, gender, course):
        self.name = name
        self.gender = gender
        self.course = course

class Course:
    def __init__(self, name, price, period):
        self.name = name
        self.price = price
        self.period = period

course_obj = Course('Python', 15800, '5months')     #新建课程对象

#老师与课程
t_c = Teacher('egon', 'male', course_obj)        #新建老师实例,组合课程对象
print(t_c.course.name)        #打印该老师所授的课程名


#运行结果
#Python

组合与继承都是有效地利用已有类的资源的重要方式,但是二者的概念和使用场景皆不同。

1. 继承的方式

通过继承建立了派生类与基类之间的关系,它是一种’是’的关系,比如白马是马,人是动物。

当类之间有很多相同的功能,提取这些共同的功能做成基类,用继承比较好,比如教授是老师

>>> class Teacher:
...     def __init__(self,name,gender):
...         self.name=name
...         self.gender=gender
...     def teach(self):
...         print('teaching')
... 
>>> 
>>> class Professor(Teacher):
...     pass
... 
>>> p1=Professor('egon','male')
>>> p1.teach()
teaching

2. 组合的方式

用组合的方式建立了类与组合的类之间的关系,它是一种‘有’的关系,比如教授有生日,教授教python课程

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def teach(self):
        print('teaching')
class Professor(Teacher):
    def __init__(self,name,gender,birth,course):
        Teacher.__init__(self,name,gender)
        self.birth=birth
        self.course=course

p1=Professor('egon','male',
             BirthDate('1995','1','27'),
             Couse('python','28000','4 months'))

print(p1.birth.year,p1.birth.month,p1.birth.day)
print(p1.course.name,p1.course.price,p1.course.period)


#运行结果:
#1 27
#python 28000 4 months

 

 组合实例:

 1 #组合重用代码
 2 class Teacher:
 3     def __init__(self, name, sex, args):
 4         self.name = name
 5         self.sex = sex
 6         self.args = args
 7 
 8 class Student:
 9     def __init__(self, name, sex, args):
10         self.name = name
11         self.sex = sex
12         self.args = args
13 
14 class Course:
15     def __init__(self, name, price, period):
16         self.name = name
17         self.price = price
18         self.period = period
19 
20 class Birth:
21     def __init__(self, year, month, day):
22         self.year = year
23         self.month = month
24         self.day = day
25 
26 class Score:
27     def __init__(self, score):
28         self.score = score
29 
30     def score_grade(self):
31         if self.score > 90:
32             g = 'A'
33         elif self.score > 80:
34             g = 'B'
35         elif self.score > 70:
36             g = 'C'
37         elif self.score > 60:
38             g = 'D'
39         else:
40             g = 'F'
41         return g
42 course_obj = Course('Python', 15800, '5months')     #课程
43 birth_obj_t = Birth(2000, 4, 19)                    #老师生日
44 birth_obj_s = Birth(2009, 9, 21)                    #学生生日
45 score_obj = Score(91)                               #学生成绩
46 #老师与课程
47 t_c = Teacher('egon', 'male', course_obj)
48 print('%s老师教授%s' % (t_c.name, t_c.args.name))      #打印该老师所授的课程名
49 #学生与课程
50 s_c = Student('jack', 'male', course_obj)
51 print('%s学习%s' % (s_c.name, s_c.args.name))
52 #老师与生日
53 t_b = Teacher('egon', 'male', birth_obj_t)
54 print('%s老师生日为:%s年 %s月 %s日'%(t_b.name, t_b.args.year, t_b.args.month, t_b.args.day))
55 #学生与生日
56 s_b = Student('jack', 'male', birth_obj_s)
57 print('%s学生生日为:%s年 %s月 %s日'%(s_b.name, s_b.args.year, s_b.args.month, s_b.args.day))
58 #学生和分数
59 s_s = Student('jack', 'male', score_obj)
60 print('%s学生的成绩为%s,等级为%s' % (s_s.name, s_s.args.score, s_s.args.score_grade()))
61 
62 
63 #运行结果:
64 #egon老师教授Python
65 #jack学习Python
66 #egon老师生日为:2000年 4月 19日
67 #jack学生生日为:2009年 9月 21日
68 #jack学生的成绩为91,等级为A

 

 

参考资料:

 

相关文章