Python--面向对象--类的继承

最新推荐文章于 2024-06-27 16:50:30 发布
最新推荐文章于 2024-06-27 16:50:30 发布
阅读量2k 收藏 21
点赞数 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/python_lqx/article/details/90346152
版权

类的继承

基本概念

面向对象三要素之一，继承Inheritance
在面向对象的世界中，从父类继承，就可以直接拥有父类的属性和方法，这样可以减少代码、多复用。子类可以定义自己的属性和方法

定义

格式如下

class 子类名(基类1[,基类2,...]):
	语句块

如果类定义时，没有基类列表，等同于继承自object。在Python3中，object类是所有对象的根基类

class A:
	pass
# 等价于
class A(object):
	pass

注意，上例在Python2中，两种写法是不同的
Python支持多继承，继承也可以多级

  • 继承
    class Son(Father) 这种形式就是父类继承，括号中写上继承的类的列表
    继承可以让子类从父类获取特征（属性和方法）
  • 父类
    Father就是Son的父类，也称为基类、超类
  • 子类
    Son就是Father的子类，也称为派生类

单一继承(括号类写一个)

class Animal:
    def shout(self):
        print('Animal shouts')

class Cat(Animal):
    pass

a = Animal()
a.shout() # Animal shouts
c = Cat()
c.shout() # Animal shouts

取当前实例类型的名称

class Animal:
    def shout(self):
        print('{} shouts'.format(type(self).__name__))

class Cat(Animal):
    pass

a = Animal()
a.shout() # Animal shouts
c = Cat()
c.shout() # Cat shouts

继承的特殊属性和方法

在这里插入图片描述

class Animal:
    def shout(self):
        print('{} shouts'.format(type(self).__name__))

class Cat(Animal):
    pass

class Dog(Animal):
    pass

print(Cat.__base__) # 类的基类 
print(Dog.__bases__) # 类的基类元祖 
print(Animal.__bases__)  # 类的基类元祖 

# mro：方法解析顺序，可看清楚继承路线
print(Cat.mro() # 显示方法查找顺序，基类的列表
print(Cat.__mro__) #显示方法查找顺序，基类的元组

print(Animal.__subclasses__()) # 类的子类列表

# 打印结果
<class '__main__.Animal'>
(<class '__main__.Animal'>,)
(<class 'object'>,)
[<class '__main__.Cat'>, <class '__main__.Animal'>, <class 'object'>]
(<class '__main__.Cat'>, <class '__main__.Animal'>, <class 'object'>)
[<class '__main__.Cat'>, <class '__main__.Dog'>]
  • int的子类
print(int.__subclasses__()) # [<class 'bool'>]

继承中的访问控制

class Animal:
   __COUNT = 100
   HEIGHT = 0

   def __init__(self,age, weight, height):
       self.__COUNT += 1
       self.age = age
       self.__weight = weight
       self.HGIGHT = height

   def eat(self):
        print('{} eat'.format(self.__class__.__name__))

   def __getweight(self):
        print(self.__weight)

   @classmethod
   def showcount1(cls):
        print(cls)
        print(cls.__dict__)
        print(cls.__COUNT)

   @classmethod
   def __showcount2(cls):
        print(cls.__COUNT)

   def showcount3(self):
        print(self.__COUNT)

class Cat(Animal):
    NAME = 'CAT'
    __COUNT = 200

# c = Cat() # __init__ 函数参数错误
c = Cat(3, 5, 15)
c.eat() # Cat eat
print(c.HEIGHT) #  0

# print(c.__COUNT)
# AttributeError, 可通过c._Animal__COUNT访问 # 101

# c.__getweight()
# AttributeError, 可通过c._Animal__getweight()访问 # 5

c.showcount1()
# 打印结果
# <class '__main__.Cat'>
# {'__module__': '__main__', 'NAME': 'CAT', '_Cat__COUNT': 200, '__doc__': None}
# 100

# c.__showcount2
# AttributeError # 可通过c._Animal__showcount2访问

c.showcount3() # 101
print(c.NAME) # CAT

print("{}".format(Animal.__dict__))

print("{}".format(Cat.__dict__))
# {'__module__': '__main__', 'NAME': 'CAT', '_Cat__COUNT': 200, '__doc__': None}
print(c.__dict__) 
# {'_Animal__COUNT': 101, 'age': 3, '_Animal__weight': 5, 'HGIGHT': 15}

print(c.__class__.mro()) 
# [<class '__main__.Cat'>, <class '__main__.Animal'>, <class 'object'>]

方法的重写、覆盖override

class Animal:
    def shout(self):
        print('Animal shouts')

class Cat(Animal):
    # 覆盖了父类方法
    def shout(self):
        print('miao')

a = Animal()
a.shout()
c = Cat() # Animal shouts
c.shout() # miao

print(a.__dict__)
print(c.__dict__)
print(Animal.__dict__)
print(Cat.__dict__)
  • Cat中能够有覆盖自己的方法?
class Animal:
    def shout(self):
        print('Animal shouts')

class Cat(Animal):
    # 覆盖了父类的方法
    def shout(self):
        print('miao')
        
    # 覆盖了自身的方法，显示调用了父类的方法
    def shout(self):
        print(super()) # <super: <class 'Cat'>, <Cat object>>
        print(super(Cat, self)) # <super: <class 'Cat'>, <Cat object>>
        print(super(self.__class__, self)) # <super: <class 'Cat'>, <Cat object>>

        super().shout() # Animal shouts
        super(Cat, self).shout() # 等价于super() # Animal shouts
        self.__class__.__base__.shout(self) # 不推荐 # Animal shouts


a = Animal()
a.shout() # Animal shouts
c = Cat() 
c.shout() # miao

print(a.__dict__)
print(c.__dict__)
print(Animal.__dict__)
print(Cat.__dict__)

super()

  • 可以访问到父类的类属性

类方法和静态方法

class Animal:
    @classmethod
    def class_method(cls):
        print('class_method_animal')

    @staticmethod
    def static_method():
        print('static_method_animal')

class Cat(Animal):
    @classmethod
    def class_method(cls):
        print('class_method_cat')

    @staticmethod
    def static_method():
        print('static_method_cat')

c = Cat()
c.class_method() # class_method_cat
c.static_method() # static_method_cat

print(Cat.__dict__)
print(Animal.__dict__)

Cat.static_method() # static_method_cat
Animal.static_method() # static_method_animal

这些方法都可以覆盖，原理都一样，属性字典的搜索顺序

继承时使用初始化

  • 初始化只跟实例字典相关
class A:
    def __init__(self,a, d=10):
        self.a = a
        self.d = d

class B(A):
    def __init__(self, b, c):
        A.__init__(self, b + c, b - c)
        self.b = b
        self.c = c

    def printv(self):
        print(self.b) # 200
        print(self.a) # 500

f = B(200, 300)
print(f.__dict__) # {'a': 500, 'd': -100, 'b': 200, 'c': 300}
print(f.__class__.__bases__) # (<class '__main__.A'>,)
f.printv()
  • 如果父类定义了__init__方法，应该在子类的__init__中调用它
  • 那么，子类什么时候自动调用父类的__init__方法呢？

示例1

class A:
    def __init__(self):
        self.a1 = 'a1'
        self.a2 = 'a2'
        print('init in A')

class B(A):
   pass

b = B() # init in A
print(b.__dict__) # {'a1': 'a1', 'a2': 'a2'}

B实例的初始化会自动调用基类A的__init__方法，所以print('init in A')会打印出来

示例2

class A:
    def __init__(self):
        self.a1 = 'a1'
        self.a2 = 'a2'
        print('init in A')

class B(A):
   def __init__(self):
       self.b1 = 'b1'
       print('init in B')

b = B() # init in B
print(b.__dict__) # {'b1': 'b1'}

B实例一旦定义了初始化__init__方法，就不会自动调用父类的初始化__init__方法，需要手动调用

class A:
    def __init__(self):
        self.a1 = 'a1'
        self.a2 = 'a2'
        print('init in A')

class B(A):
   def __init__(self):
       self.b1 = 'b1'
       print('init in B')
       A.__init__(self)

b = B() # init in B

print(b.__dict__) # 注意看__a2
# init in A
# {'b1': 'b1', 'a1': 'a1', '_A__a2': 'a2'}

正确初始化

class Animal:
    def __init__(self, age):
        print('init in Animal')
        self.age = age

    def show(self):
        print(self.age)

class Cat(Animal):
    def __init__(self, age, weight):
        # 调用父类的__init__方法的顺序有时决定着show方法的结果
        super().__init__(age)
        print('init in Cat')
        self.age = age + 1
        self.weight = weight
        super().__init__(age)

c = Cat(10, 5)
# 打印结果
# init in Animal
# init in Cat
# init in Animal
c.show() #10
  • 注意，调用父类的__init__方法，出现在不同的位置，可能导致出现不同的结果
  • 将上例中所有的实例属性改成私有变量
class Animal:
    def __init__(self, age):
        print('init in Animal')
        self.__age = age

    def show(self):
        print(self.__age)

class Cat(Animal):
    def __init__(self, age, weight):
        # 调用父类的__init__方法的顺序有时决定着show方法的结果
        super().__init__(age)
        print('init in Cat')
        self.__age = age + 1
        self.__weight = weight
        super().__init__(age)

c = Cat(10, 5)
# 打印结果
# init in Animal
# init in Cat
# init in Animal
c.show() # 10

print(c.__dict__) # {'_Animal__age': 10, '_Cat__age': 11, '_Cat__weight': 5}
  • 上例中打印10，原因看__dict__就知道了。因为父类Animal的show方法中_age会被解释为_Animal__age，因此显示的是10，而不是11
  • 这样的设计不好，Cat的实例c应该显示自己的属性值更好

解决的办法：

  • 一个原则，自己的私有属性，就该自己的方法读取和修改，不要借助其他类的方法，即使是父类或者派生类的方法
鹿夏
关注
  • 5
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Python中类的继承
兰枫
05-19 2151
文章目录Python中类的继承继承继承中的访问控制方法的重写、覆盖override继承时使用的初始化 Python中类的继承 面向对象的三要素之一，继承inheritance 人类和猫类都继承自动物类。个体继承自父母，继承了父母的一部分特征，但也可以有自己的个性。 在面向对象的世界中，从父类继承，就可以直接拥有父类的属性和方法，这样可以减少代码、多复用。子类可以定 义自己的属性和方法。 继承 c...
Python-面向对象编程-继承
qq522044637的博客
12-27 530
继承、多重继承
python中类的继承详解
最新发布
weixin_44249280的博客
06-27 290
面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展
python之继承类
yjysunshine的博客
05-06 503
一个班级里，分学生和班长，班长也是学生，只是比一般学生多了班长的职责。现在我们有学生类，定义班长类时，我们只需要在学生属性的基础上添加上职位属性。像此种情况，就是我们在python中学到的继承思想，即已有学生类，班长类有学生类的全部属性，且还需要在学生类的基础上添加上自己独有的属性。 如以上例子，Monitor类继承自Student类，类名后面的括号中填写继承的类名，没有继承类名的需要填写o...
Python class类的继承
GMH的博客
05-27 5833
面向对象的编程带来的主要好处之一是代码的重用，实现各种重用的方法之一是通过继承机制。继承完全可以理解成类之间的父类和子类型关系。 继承概念：继承是类与类的一种关系，是一种子类与父类的关系，即爸爸与儿子，爸爸生个儿子，儿子继承爸爸的属性和方法。 如猫类，猫是动物；猫类继承于动物类，动物类为父类也是所有动物的基类；猫类是动物类的子类，也是动物类的派生类。 Python有单继承与多继承。单继承即子类继承于一个类，多继承即子类继承于多个类，多继承会比较少遇到，本章节主要讲单继承。 什么时候使用继承：假如我需
(2020年11月2日学习笔记)闭包深入理解，对象继承的方法（原型链继承，构造继承，语法糖继承）
丢失的Litte_志伟的博客
11-02 422
一：闭包 ​ 在一些使用场景中，我们不想使用全局变量，但是又不想每次使用后改变其值，这个时候该怎么做呢。高级一点说”一个变量既能重复使用，又不会污染全局“这时候闭包就产生了 闭包的重要理解：闭包可以在全局函数里面操作另一个作用域的局部变量 形成闭包的步骤 一：外层函数嵌套内层函数 二：内层函数访问外层函数的变量 三：外层函数的返回值为内层函数（注：不是返回内层函数的结果而是内层函数） 闭包的实现原理 这里引用了熊大林老师的关于闭包深入理解的文章 2、外层函数调用时 3、外层函数调用后 4、内层函数调用
python-面向对象-08类属性
12-20
总结，类属性是Python面向对象编程中一个重要的概念，它为类提供了一种共享数据的方式，可以用来实现某些全局状态或统计信息。理解类属性及其用法，对于编写高效、可维护的Python代码至关重要。
python-2.7.12.amd64.rar
10-06
4. **面向对象编程**：Python 支持类和对象的概念，可以创建自定义的类以及进行继承、封装和多态操作。 5. **文件操作**：学会如何打开、读取、写入和关闭文件，是 Python 编程中常见的任务。 6. **模块和包**：了解...
python_Python-introduction_
10-01
在"Python introduction"这个主题中，我们将深入探讨Python的基础知识，包括安装、基本语法、数据类型、控制结构、函数、模块和面向对象编程等核心概念。 首先，让我们从安装Python开始。Python官网提供最新版本的...
Python-面向对象(一)
12-20
而面向对象编程则强调对象的封装、继承和多态，使得代码更易于理解和维护，提高了代码的复用性。 在Python中，一切都是对象。你可以定义自己的类来创建新的对象类型。类是一种蓝图或模板，用于创建具有特定属性和...
Python-OpenMafia开源Mafia游戏引擎
08-10
1. **面向对象编程**：Python-OpenMafia基于Python的面向对象编程思想构建，通过类和对象来抽象游戏中的角色、事件和规则。开发者可以通过继承和多态性来实现游戏的各种定制需求。 2. **模块化设计**：Python支持...
python-继承
weixin_45127969的博客
11-25 166
5.2 继承 #创建子类时，父类必须包含在当前文件中，且位于子类前面。在处，我们定义了子类ElectricCar。定义子类时，必须在括号内指定父类的名称。方法__init__()接受创建Car实例所需的信息。 class Car: def __init__(self, make, model, year): self.make = make self.model = model self.year = year self.odomete
python 单继承
jamieblue1的博客
04-03 172
# 单一继承 class A(object): def __init__(self): print("这是A的init") class B(A): # B继承A, A是父类，B是子类 def __init__(self): super(B, self).__init__() # 调用父类A的init print('这是...
python单继承
qq_42109746的博客
02-06 439
一、继承的概念： 子类拥有父类的所有属性和方法。 二、继承的语法： class 类名（父类名）: pass 子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发。 子类中应该根据职责，封装子类特有的属性和方法。 三、专业术语： 狗类是动物类的子类，动物类是狗类的父类，狗类从动物类继承。 狗类是动物类的派生类，动物类是狗类的基类，狗类从动物类派生。 四、继承的传...
Python入门 class类的继承
qq_15821487的博客
08-05 285
https://zhuanlan.zhihu.com/p/30239694 面向对象的编程带来的主要好处之一是代码的重用，实现各种重用的方法之一是通过继承机制。继承完全可以理解成类之间的父类和子类型关系。 继承概念：继承是类与类的一种关系，是一种子类与父类的关系，即爸爸与儿子，爸爸生个儿子，儿子继承爸爸的属性和方法。 如猫类，猫是动物；猫类继承于动物类，动物类为父类也是所有动物的基类；猫类是动物类的子类，也是动物类的派生类。 Python有单继承与多继承。单继承即子类继承于一个类，多继承即子类继承于多
Python:类的继承与多态、类方法(@classmethod)
Vying_king的博客
08-18 420
Python:类的继承与多态、类方法(@classmethod)
Python---面向对象(类的继承)
m0_72596958的博客
08-22 227
Python---面向对象(类的继承)
python 类 继承 经典例子_pythonl类继承例子
weixin_42553471的博客
12-30 223
#coding=utf-8class Person(object):def __init__(self,name,age):self.name=nameself.age=agedef get_age(self):return self.agedef get_name(self):return self.namedef set_age(self,age):if age>=0 and age&l...
python单一继承_Python-继承(单继承&多继承)-Go语言中文社区
weixin_42151036的博客
02-03 210
面向对象有三大特性：封装、继承和多态封装：根据职责将属性和方法封装到一个类中继承：可以实现代码重用，相同的代码不需要重复编写多态：不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度为什么需要继承首先我们看以下的一个例子我们有以下几个类：Animal:其中封装了drink, eat, run 和sleep四个方法, Dog：其中也封装了eat, drink, run, sleep, 除此...
Python3.5面向对象与继承详解
在Python 3.5中，面向对象编程主要包括类的定义、对象的创建、继承以及封装等特性。 1. **编程方式**：面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计为由相互协作的对象集合组成...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值