python之封装继承多态

已于 2023-01-03 23:34:44 修改
阅读量674 收藏 13
点赞数 1
文章标签： python 开发语言
于 2023-01-03 23:27:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38039965/article/details/128396152
版权

目录

一、面向对象的三大特征

  1. 封装： 提高程序安全性，若不希望外部调用类属性，可以加两个下划线；
  2. 继承： 提高代码复用性；
  3. 多态： 提高程序的可扩展性和可维护性。

二、封装

2.1 私有化

定义：

将属性和方法写到类的内部，使实例获得较为全面的功能，并且可以将属性和方法设置私有权限，保证暴露接口的安全性。规则如下：
a. 隐藏对象的属性和实现细节，仅对外提供公共访问的方式
b. 封装原则：
       1.将不需要对外提供的内容隐藏起来
       2.把属性都隐藏，提供共公共方法对其访问；

优点：

1.可以找到一个对象能够完成所有的功能或者业务,迭代和维护较为方便
2.可以设置私有属性或方法,提高代码安全性,只暴露我们想要暴露的接口
3.可以降低模块或者类的使用难度,暴露少量接口即可完成全部功能

私有属性,私有方法：

当前属性或方法只能在类的内部进行调用,在类的外部无法使用,则称该属性,或者方法为私有属性,或者私有方法
格式: 在属性或方法前加上两个下划线 __属性名 或者 __方法名

注意：
以单划线开头的表示保护类型成员，只允许在类本身和子类中进行访问，不能通过 “ from module import * ”语句导入。


class Dog(object):
    def _eat(self):
        print('吃一根骨头')
 
    def bark(self):
        self._eat()
        print('汪汪汪'')
 
 
d1 = Dog()
d1.bark()

结果：
在这里插入图片描述

2.2私有属性的获取方式

# 一般情况下,我们不会强行调用私有属性和方法
# 我们会设置 get方法和set方法进行调用和修改
 
class Dog(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
    # 如果一个数据只能存储数据,无法使用其中的数据,那这个数据存储方案将没有任何意义
    def get_age(self):
        return self.__age
 
    def set_age(self, age):
        self.__age = age

 
 
d1 = Dog('小黑', 18)
# 使用get方法,可以直接调用私有属性
print(d1.get_age())
# 在使用set方法时,可以对私有属性进行赋值
d1.set_age(45)
print(d1.get_age())

结论: 使用get，set方法可以对私有属性进行赋值和获取，在类的外部也可以使用
在这里插入图片描述

三、继承

继承顺序： 对象>子类>父类>父父类

3.1 单继承

单继承就是某个类只继承自一个父类，同时，继承关系中可以有多级继承
继承过程中，子类可以使用父类的所有非私有属性或方法
如果父类或更高级的父类，实现了init方法，并且进行了参数设定，实例化子类对象时必须传值。

# 单继承:一个子类,只继承一个父类,并且可以多级继承
 
# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
# 定义一个Father类,继承Person
class Father(Person):
    def __sing(self):
        print('唱歌')
 
    def dance(self):
        print('跳舞')
 
# 定义一个Son类,继承Father
class Son(Father):
	# 继承父类时,只能继承父类中的非私有属性和方法
	pass
s1 = Son('小明', 26)
结果：

在这里插入图片描述

结论：

1、在继承中可以多级继承，子类中可以使用父类及父类的父类中非私有的属性和方法
2、如果在父类或者更高级的父类中实现了init方法，并且书写了参数,则实例化对象时，必须传值

查询类的继承链条
Son.mro

(<class ‘main.Son’>, <class ‘main.Father’>, <class ‘main.Person’>, <class ‘object’>)
使用 类名.mro 可以输出类的继承链条，同时这个 顺序也是方法或属性查找的顺序

3.2 多继承

一个子类，继承多个父类的过程就是多继承
在多继承中，子类可以调用多个父类中的非私有方法或者属性
多继承中，如果出现同名属性或方法，优先调用继承位置靠前的父类中的方法或属性

# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
# 定义一个Father类,继承Person
class Father(Person):
    def father_sing(self):
        print('爸爸唱歌')
 
    def dance(self):
        print('爸爸跳舞')
# 定义一个math类,继承Person
class Mother(Person):
    def mom_sing(self):
        print('妈妈唱歌')
 
    def dance(self):
        print('妈妈跳舞')
 
# 定义一个Son类,继承Father
class Son(Mother, Father):
	# 继承父类时,只能继承父类中的非私有属性和方法
	pass
s1 = Son('小明', 26)
结果：

在这里插入图片描述

结论：

如果存在同名方法，在继承时,谁的继承位置更靠前就调用谁内部的代码

3.3 子类重写父类方法

子类中重写父类方法重写父类方法，则调用方法时，直接调用子类中的方法，不会调用父类的（因为在调用方法或者属性时，会按照继承层级依次查找）
重写时只要方法名称*相等即可，不需要进行参数的校对

# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
 
# 定义一个Father类,继承Person
class Father(Person):
    def sing(self):
        print('爸爸唱歌')
        
 
    def dance(self):
        print('爸爸跳舞')
 
# 定义一个Son类,继承Father
class Son(Father):
	# 继承父类时,只能继承父类中的非私有属性和方法
	def sing(self):
		print('儿子唱歌')

s1 = Son('小明', 26)
结果：

在这里插入图片描述

3.4 super（）方法

super（）方法的存在就是为了解决多重继承的问题，在一个父类中使用super（）方法用于调用下一个父类的方法

# 定义一个Person类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age
        print('from init')
 
# 定义一个Father类,继承Person
class Father(Person):
    def sing(self):
        print('爸爸唱歌')
        super().sing()
 
    def dance(self):
        print('爸爸跳舞')
        
class Mother(Person):
    def sing(self):
        print('妈妈唱歌')
 
    def dance(self):
        print('妈妈跳舞')
 
# 定义一个Son类,继承Father
class Son(Father,Mother):
    # 继承父类时,只能继承父类中的非私有属性和方法
    def sing(self):
        print('儿子唱歌')
        super().sing()

s1 = Son('小明', 26)
结果：

在这里插入图片描述

四、多态

4.1 概念

多态是指在执行相同代码情况下，根据对象所属类的不同去调用相应类的方法，从而执行不同效果。
两个前提：
1.继承----多态一定是发生在子类和父类之间；
2.重写----子类重写了父类的方法

实例一：

# 定义Person类
class Person(object):
    def __init__(self, name="小明"):
        # _name 为私有属性
        self._name = name
 
    def drink(self):
        print(self._name + "喝水")
 
 
# 定义一个Father类,继承Person
class Father(Person):
    # 对父类的 sleep 方法进行了扩展
    def drink(self, name):
        super().drink();
        print(name + "喝水")
  
        
class Mother(Person):
    def drink(self):
        print("妈妈喝水")
 
 
father = Father()
# 调用父类的 drink 方法
father.drink("小红");
 
mother = Mother()
# 调用父类的 drink 方法
mother.drink()
结果：

小明喝水
小红喝水

妈妈喝水

实例二： 
class Animal(object):
    def run(self):
        print("Animal running")


class Bird(Animal):
    def run(self):
        print("a bird sleeps in tree")


class Fish(Animal):
    def run(self):
        print("a fish sleeps in water")


def goSleep(Animal):
    Animal.run()

fish = Fish()
bird = Bird()

goSleep(fish)
goSleep(bird)
结果：

a fish sleeps in water
a bird sleeps in tree

多态的意义：

  1. 对于一个变量，我们只需要知道他是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法（调用方只管调用，不管细节）
  2. 当需要新增功能，只需要新增一个Animal的子类实现run()方法，就可以在原来的基础上进行功能扩展，这就是著名的“开放封闭”原则：​​​​​​​

“开放封闭”原则：

  1. 对扩展开放：允许新增Animal子类
  2. 对修改封闭：不需要修改依赖Animal类型的run()等函数

注意点： Python中函数的参数是没有类型限制的，所以多态在python中的体现并不是很严谨。多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
即：在Python中编写一个函数，传递实参前其参数的类型并不确定，在函数中使用形参进行操作时只要传入的对象能够支持该操作程序就可以正常执行。

4.2内置函数（isinstance、ssubclass、type）

4.2.1 isinstance

       用于判断一个对象所属的类是否是指定的类或指定类的子类
用法：
       isinstance(object, classinfo)

       object – 实例对象。
       classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值：
       相同则返回 True，否则返回 False。
例：

# 定义一个Person类
class Person(object):
    pass
 
# 定义一个Father类,继承Person
class Father(Person):
    pass
 
father = Father() 

print(isinstance(father,Person))

print(issubclass(Father,Person))

print(type(father)==Father)

# 结果为Ture

print(type(father)==Person)
# 结果为False

4.2.2 issubclass

       用于判断一个类是不是另一类的子类
用法：
      &nbspissubclass(class, classinfo)
参数：
      class – 子类。
      classinfo – 父类。

返回值：
       相同则返回 True，否则返回 False。

4.2.3 type

       用于获取一个对象所属的类
用法：
       type(class)==classinfo
参数：
      class – 子类。
      classinfo – 父类。

返回值：
       相同则返回 True，否则返回 False。

五、类属性和类方法

通过 类名.类属性 或者 类名.类方法 来访问类属性和类方法

5.1 类属性

不需要创建类的对象，通过 类名. 的⽅式就可以访问类的属性或者调用类的方法 。

# 定义Cat类
class Cat:
    # name 为类属性，通过 Cat.name 访问
    name = "小黄" 
print(Cat.name)

5.2 类方法

  1. 用 @classmethod 修饰的方法为类方法；
  2. 类方法的参数为 cls，在类方法内部通过 cls.类属性 或者 cls.类方法 来访问同一个类中的其他类属性和类方法；
  3. 类方法不需要实例化就可以调用，类方法只能访问同一个类中的类属性和类方法

@classmethod
def 静态⽅法名(cls):
       pass

# 定义Cat类
class Cat(object):
 
    def __init__(self, name="小白"):
        # _name 为私有属性
        self._name = name
 
    # drink 为类方法
    @classmethod
    def drink(cls):
        print(cls.name + "喝水")
 
Cat.drink()

5.3 静态方法

如果需要在类中封装⼀个⽅法，这个⽅法既不需要访问实例属性 或者调⽤实例⽅法，也不需要访问类属性或者调⽤类⽅法, 这个时候，可以把这个⽅法封装成⼀个静态⽅法。

  1. 用 @staticmethod 修饰的方法为静态方法；
  2. 静态方法是独立存在的，不能访问类或者实例的任何属性和方法；
  3. 通过 类名.静态方法 调⽤静态⽅法 。

@staticmethod
def 静态⽅法名():
       pass

# 定义Cat类
class Cat(object):
    # drink 为类的静态方法
    @staticmethod
    def drink():
        print("喝水")
        
Cat.drink()

5.4 property属性

使用 @property 装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改。

用法主要有两点：

  1. 将方法当做属性来使用
  2. 将属性设置为只读

5.4.1 修饰方法，是方法可以像属性一样访问。

class DataSet(object):
	@property
	def method_with_property(self): #含有@property
    	return 15
    
    #不含@property
    def method_without_property(self): 
    	return 15

data_set = DataSet()
# 加了@property后，可以用调用属性的形式来调用方法,后面不需要加（）。
print(data_set.method_with_property) 

#没有加@property , 必须使用正常的调用方法的形式，即在后面加()
print(data_set.method_without_property())

5.4.2 与所定义的属性配合使用，防止属性被修改

由于python进行属性的定义时，没办法设置私有属性，因此要通过@property的方法来进行设置。这样可以隐藏属性名，让用户进行使用的时候无法随意修改。

class DataSet(object):
	def __init__(self):
		#定义属性的名称
    	self._images = 1
    
    # 方法加入@property后，这个方法相当于一个属性，这个属性可以让用户进行使用，而且用户有没办法随意修改。
    @property
    def images(self): 
        return self._images 

data_set = DataSet()

#用户进行属性调用的时候，直接调用images即可，而不用知道属性名_images，因此用户无法更改属性，从而保护了类的属性。
print(data_set.images)
注意点：
  1. 属性名与方法名一定要区分开，不然会进入死循环
  2. 实例化的对象使用属性时，不是调用属性，而是用的方法名
  3. @property其实就是实现了getter功能； @xxx.setter实现的是setter功能；还有一个
    @xxx.deleter实现删除功能
  4. 定义方法的时候 @property必须在 @xxx.setter之前，且二者修饰的方法名相同
  5. 如果只实现了 @property（而没有实现@xxx.setter），那么该属性为 只读属性
class DataSet(object):
    def __init__(self):
        #定义属性的名称
        self._images = 1
    
    # 方法加入@property后，这个方法相当于一个属性，这个属性可以让用户进行使用，而且用户有没办法随意修改。
    @property
    def images(self): 
        return self._images 

    @images.setter
    def images(self, value): 
        self._images = value

data_set = DataSet()
# 输出images属性
print(data_set.images)
# 复制images属性
data_set.images = 3
print(data_set.images)


# 结果为：
1
3
Zaeton
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
python之封装、继承、多态
weixin_44118591的博客
07-31 359
目录 封装 继承 继承的基本使用 私有属性的继承特点 新式类和经典类 子类重写父类的方法 多态 Java和python多态使用的不同表现 封装 封装：即打包 函数是对语句的封装 类是对函数和变量的封装 继承 继承的基本使用 什么是继承？ 继承是一种创建新的类的方式，新创建的叫子类，继承的叫父类、超类、基类。 特点：子类可以使用父类的属性（特征、技能） 继承是类与类之间的关系 为什么要使用继承？ 减少代码冗余、提高重用性 继承的使用 单继承 cl...
python中的封装继承多态_Python入门之类 封装、继承、多态
weixin_31475247的博客
01-13 340
Python入门之类(class)Python3 面向对象Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。接下来...
Python入门基础教程：继承、封装、多态 (非常详细)
xx16755498979的博客
07-17 3641
这篇文章介绍 面向对象的三大特征——封装，继承，多态。
Python中的封装、继承与多态
Mr_WoLong
05-30 1389
封装就是：我写了一个类，我将一个类的属性、方法全部包装到了一个类中。我对类中某些方法和属性进行了隐藏，（外部实例化之后，无法通过对象.方法或对象.属性来进行直接调用）。因为我不想让外部了解我的实现机理或属性，但是会留出一些公开的方法来供外部间接调用这些“封装”好的属性和方法！这就是封装！！！
Python中的封装、继承与多态（史上最简单易懂版）
Elon15的博客
10-06 3662
Python中的封装、继承与多态（史上最简单易懂版）
【Python面向对象】封装、继承、多态
尹煜的博客
05-02 5293
面向对象有三个基本特征，分别是封装、继承和多态。其中，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用/调用！本文将利用Python语言进行简单举例，以帮助大家更好地理解这三个特征。
Python基础教程：第十章 面向对象（二）【封装，继承，多态】
Blue92120的博客
05-25 484
那么除了对用户开放以外，手机中也会有一系列对用户隐藏的属性和行为，比如说手机的运行电压驱动信息，这些属性我们用户一般是无法获取的，另外包括像程序调度、内存管理这些行为也不是对我们用户开放的，那所以说我们的手机它会既有对用户开放的属性和行为，也会有对用户隐藏的属性和行为。实际上，产生的新设计图本质上是继承老的设计图的，相当于复制粘贴了一份，然后进行修改。那我们再来想一下，在我们的现实世界中，这些不公开的属性和行为我们用户是无法直接使用的，那么程序中我们定义的这些私有的成员他是否能够满足？
Python 面向对象之封装、继承、多态操作实例分析
09-18
面向对象编程是Python中的核心概念，它包括三个关键特性：封装、继承和多态。这些特性使得代码更加模块化、可复用和易于维护。 **封装**是面向对象编程的基础，它涉及将数据和操作数据的方法绑定在一起，形成一个...
Python类继承和多态原理解析
12-20
Python 类继承和多态原理是面向对象编程中的核心概念，它们极大地增强了代码的复用性和灵活性。在这篇文章中，我们将深入探讨这两个主题。...了解和熟练掌握类继承、多态和封装是成为优秀Python开发者的关键步骤。
Python的继承多态
12-20
总结来说，Python的继承多态提供了强大的代码复用和扩展能力，通过私有属性和方法实现数据封装，单例模式确保类只有一个实例，而多态则提高了代码的灵活性和可维护性。在实际开发中，熟练掌握这些概念能帮助我们编写...
【初学者必备】python封装继承多态笔记
06-13
### Python面向对象编程基础：封装、继承与多态 #### 封装 **定义与作用：** 封装是面向对象编程的一个基本概念，指的是将数据及其相关的操作捆绑在一起，对外提供一个干净的接口，隐藏实现细节。封装使得代码更加...
一文总结：Python的封装、继承和多态
weixin_68789096的博客
03-07 1157
这样，相同的方法或属性的调用可以产生不同的结果，取决于对象的类型。
python封装、继承、多态
小长的博客
09-04 218
一、封装是使用私有属性时会用到 1.封装理解 1.1语法角度：把对象的属性设置为私有属性，再编写两个方法，get方法获取私有属性的值，set方法设置私有属性的值 1.2应用角度：封装隔离了代码的复杂度；封装提高了属性的安全性 2.私有属性不能在类外部使用 class People: def __init__(self,name,age,money): self.name=name self.age=age self.__money = mo
Python面向对象编程：进阶篇（封装、继承和多态）
TiYong的博客
03-17 1283
面的文章里面，我们讲了面向对象的入门概念：Python面向对象编程：入门篇（类和对象），接下来，我们继续学习进阶的内容封装、继承和多态。 封装、继承和多态作为Python面向对象编程（OOP）三个核心概念，它们是面向对象程序设计的基石，允许我们以更加模块化、可维护的方式编写代码。下面我们一起来学习。
python 的封装，(继承和多态)
qq_35027690的博客
12-27 324
面向对象编程的三个基本特征是：封装，继承，多态。下面就python来理解一下这三个特征。 1.封装   从表面上看，对象封装了对象的属性和方法，使之成为一个独立性很强的模块。 另外，封装可以看作一个屏障，一种信息隐蔽技术，防止该类被其他类任意访问，必须通过指定的方式对该类进行访问，增加了代码的安全性。   从生活中的例子看，开车的人并不需要明白汽车的工作原理，汽车的工作原理对用户封装起来，用户只需...
Python 封装、继承、多态
qq_49873907的博客
04-10 646
封装、继承、多态。
2024年Python最新python之类的封装，继承，多态
2301_82243979的博客
05-01 792
在属性名和方法名前面加两个下划线__定义为私有属性和私有方法，不能被子类继承获取，定义getXXX()修改，定义setXX()4，方法用装饰器@classmethod标识用装饰器@staticmethod标识5，魔法方法a，__init__()：初始化对象在创建一个对象时默认被调用，不需要手动调用b，带参数的__init__()方法a，print输出对象时，默认打印的是对象在内存中的地址b，如果类中定义__str__方法，则会打印__str__方法中的内容二，继承====1，单继承父类，class 父类(o
python面向对象之封装、继承与多态
菜鸟学识的博客
03-17 1186
⾯向对象三⼤特性分别是封装，继承，多态。所谓继承其实就是类与类之间的关系，⽽继承的⽬的就是为了解决代码重⽤问题，所以继承在某些⽅⾯来说，它是⼀种创建新类的⽅式，在Python中，⼀个类可以继承⼀个类，也可以继承多个类。被继承的类被称为:基类，继承别⼈的类，被称为:派⽣类。passpasspasspass执⾏如上的代码后，输出的结果信息为:passpasspass执⾏代码后，输出的结果信息:特别注意:⼦类可以继承⽗类所有的⽅法以及属性。单继承。
python对象的三大特性介绍：封装/多态/继承
kymppcds的博客
02-18 1017
本文介绍了类的三个重要特性封装/多态/继承，相信只是其中一部分知识点，希望达到抛砖引玉的效果，我们大家继续更深层次的学习和探索。
python的封装继承多态
最新发布
07-30
在Python中，封装、继承和多态是面向对象编程的三大核心特性： 1. **封装**（Encapsulation）：它是指将数据和操作这些数据的方法组合在一起，形成一个独立的对象。在Python中，通过定义类并隐藏内部细节（如私有变量__private）来实现封装。用户只能通过公开的方法来访问和修改对象的状态。 2. **继承**（Inheritance）：让一个类（子类）从另一个类（父类）获取属性和方法，子类可以拥有父类的所有特征，并且还可以添加自己的特性和行为。在Python中，通过使用`class DerivedClass(ParentClass):`语法来创建继承关系。 3. **多态**（Polymorphism）：同一种行为可以在不同的类中有不同的实现。Python支持动态多态，即方法绑定是在运行时根据实例类型确定的。这通常通过函数重载（Python不直接支持，但可以通过鸭子类型实现类似效果）和方法覆盖（通过继承和重写父类方法）来体现。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值