【python】（六）python的封装、继承和多态

已于 2022-09-13 15:45:27 修改
阅读量886 收藏 13
点赞数 1
分类专栏： Python 文章标签： python 面向过程 封装 继承 多态
于 2022-09-13 15:37:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gjj920318/article/details/126834584
版权

目录

1. python面向对象编程

1.1 面向对象是什么

  • Python 是一门面向对象的语言
  • 面向对象编程（OOP）：Object Oriented Programming

所谓的面向对象，就是在编程的时候尽可能的去模拟真实的现实世界，按照现实世界中的逻辑去处理问题，分析问题中参与其中的有哪些实体，这些实体应该有什么属性和方法，我们如何通过调用这些实体的属性和方法去解决问题。

1.2 两种编程思想

  1. 面向过程

    • 一种以过程为中心的编程思想
    • 首先分析解决问题所需要的步骤
    • 然后用函数将这些步骤一步一步的实现
    • 最后按顺序依次调用运行

  2. 面向对象

    • 是一种更符合我们人类思维习惯的编程思想
    • 面向对象开发就是不断的创建对象，使用对象，操作对象做事情
    • 可以将复杂的事情简单化

1.3 类与对象

  • 类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了集合中每个对象所共有的属性和方法。
  • 对象(object)：也称为类的实例，是一个具体存在的实体。

2. python类与对象

2.1 类的定义

  • class 关键字
# 语法
class 类名(父类名):
    """类的帮助信息"""
    属性
    方法

# class_def.py

# 类的声明
class Human(object): #object可以省略。在python中如果没有声明继承的类的话，那默认继承的是超类object。
    """人类"""
    # 定义属性（类属性）
    message = "这是类属性"

# 通过类访问类属性
print(Human.message)

2.2 类的方法

2.2.1 实例方法

2.2.1.1 构造方法
  • 作用：实例化对象。构造方法用于构造并直接返回该类的对象，每当创建一个类的新的实例时，python会自动执行构造方法，这是创建对象的基本途径。如果开发者没有在类中定义构造方法，python会自动给该类默认添加一个构造方法。
  • 语法：def __init__(self, 参数列表)
    • self：self参数是一个指向实例的引用，用于访问类的属性和方法，在方法调用时会自动绑定到调用这个方法的本身。
    • self参数必须有，且必须处于首位。
  • 访问：类名(参数列表)
# constructor_method.py

class Human:

    # 定义属性（类属性）
    message = "这是类属性"

    # 构造方法
    def __init__(self, name, age):  
        # 实例变量（实例属性）
        self.name = name
        self.age = age
        print("这是构造方法")

# 实例化对象
person = Human("哈利波特", 12)

# 通过实例访问类属性
print(person.message)

# 通过实例访问实例属性
print(person.name)
print(person.age)
2.2.1.2 实例方法
  • 作用：实例方法是在类中定义的函数，该函数是一种在类的实例上操作的函数。实例方法提供每个类的实例共享的方法
  • 语法：def 方法名(self, 参数列表)
    • self：类的实例自身，也可以是self之外的其他单词，但建议使用约定俗成的self。第一个参数必须是self，不可省略。
    • 参数列表：自定义参数，每个参数间使用逗号分隔
  • 访问：实例.方法名(参数列表)
  • 实例方法与函数的区别：函数是实现某个独立功能；实例方法是实现类的某个行为，属于类的部分。实例方法用于定义该类的对象行为和行为实现。在类中的方法都属于实例方法。
# instance_method.py


class Human:

    # 实例方法
    def study(self, course):
        print("正在学习{course}")

# 实例化
person = Human()

# 通过实例访问实例方法
person.study("python")

2.2.2 类方法

  • 作用：类方法是指在类中使用 @classmethod 装饰器装饰的方法。用于设置或获取类的详细信息或者状态。
  • 语法：@classmethod
  • 访问：类名.类方法名(参数列表)
  • 注意：不能访问或者修改实例对象的数据 ，因为类方法绑定的是cls参数不是self参数。不使用cls不会报错，但是最好按照惯例来，cls指向对象其实就是类名本身。
# class_method.py

class Human:

    # 类属性
    population = []

    # 类方法
    @classmethod
    def born(cls): #使用类方法装饰器，定义类时会自动添加cls参数
        print("这是类方法")
        cls.population += 1


# 通过类名访问类方法
Human.born()
print(Human.population)

2.2.3 静态方法

  • 静态方法是类中使用@staticmethod装饰的方法。静态方法不需要访问数据，没有cls、self这种关键字。静态函数可以独立工作，不能设置类的状态或者实例的状态。
  • 作用：静态方法用于创建通用的工具函数。这样就可以把常用的工具函数放在一个类里,使用的时候不需要实例化就可以直接调用。
  • 语法：@staticmethod
  • 调用：类名.静态方法名()
  • 注意：调用类方法和静态方式时，我们是使用类名访问。虽然实例也可以调用类方法和静态方法，但是一般不会这样进行操作。这样可以省去实例化的步骤。
# static_method.py

class Human:

    # 静态方法
    @staticmethod
    def grow_up():#使用静态方法声明后，不会绑定cls或者self参数
        print("这是静态方法")

# 通过类名访问静态方法
Human.grow_up()

3. python封装

3.1 封装的概念

封装（Encapsulation）：

  • 隐藏：属性和实现细节，不允许外部直接访问
  • 暴露：公开方法， 实现对内部信息的操作和访问

3.2 封装的作用

  • 限制不合理的访问和操作，提高数据安全性
  • 可进行数据检查，从而有利于保证对象信息的完整性

3.3 封装的实现

3.3.1 隐藏

python中没有既定的关键字或者机制来实现真正的封装，但是使用命名方式来实现

  • 保护属性：_属性名
  • 私有属性：__属性名
    • 定义私有属性之后，python将会自动添加_类名,变相的实现了属性的隐藏，即被视为： _类名__属性名
    • 当想要通过__属性名去访问属性的话，实际上访问不到的。
#定义一个Account类
class Account:

    # 普通属性
    bank = "BOC"
    # 内部属性
    _username = "Hogwarts"
    # 私有属性
    __password = "888"


# 通过类名访问类属性
print(Account.bank)       # 将会打印 BOC
print(Account._username)  # 将会打印 Hogwarts
print(Account.__password) # 将会引发 AttributeError，打印内容：AttributeError: type object 'Account' has no attribute '__password'
print(Account.__dict__)   # 将会打印类中实际有用属性
#打印内容：{'__module__': '__main__', 'bank': 'BOC', '_username': 'Hogwarts', '_Account__password': '888', '__dict__': <attribute '__dict__' of 'Account' objects>, '__weakref__': <attribute '__weakref__' of 'Account' objects>, '__doc__': None}
#注：__dict__:python内置特殊属性，字典格式，保存类中所拥有的可写的属性

3.3.2 暴露

  1. 提供数据访问功能（getter）
  • 计算属性（通过@property合成的属性成为计算属性）
  • 语法：使用@property装饰器
  • 作用：把类中的一个方法变成一个属性
  • 调用：实例.方法名

注意： 计算属性并不真正的存储状态，其值是通过某种算法计算得到的，当程序对该属性赋值时，所赋值实际是存放在对应的实例变量中。

class Account:
    # 普通属性
    bank = "BOC"
    # 内部属性
    _username = "Hogwarts"
    # 私有属性
    __password = "888"

    @property
    def password(self):
        return self.__password

# 实例化对象
obj = Account()

# 访问实例的私有属性
print(obj.password)  # 将会打印 888
#注意：password虽然是方法，但是已经被装饰成计算属性，因此访问的时候不需要加()
  1. 提供数据操作功能（setter）
  • 语法：使用@计算属性名.setter装饰器
  • 作用：对计算属性进行赋值操作
  • 调用：实例.方法名
class Account:
    # 普通属性
    bank = "BOC"
    # 内部属性
    _username = "Hogwarts"
    # 私有属性
    __password = "888"

    @property
    def password(self):
        return self.__password

    @password.setter
    def password(self, value):
        # 增加数据的校验
        if len(value) >= 8:
            self.__password = value
        else:
            print("密码长度最少要有8位！")

# 实例化对象
obj = Account()

# 修改私有属性（满足校验条件）
obj.password = "hogwarts666"  # 修改成功
print(obj.password)  # 将会打印 hogwarts666

# 修改私有属性（不满足校验条件）
obj.password = "123"  # 修改不会生效
print(obj.password)  # 将会打印 888

4. python继承

4.1 继承的概念

继承（Inheritance）：

  • 复用父类的公开属性和方法
  • 拓展出新的属性和方法

4.2 继承的实现

  • 语法：class 类名(父类列表)
  • 默认父类是 object
  • Python 支持多继承
# inheritance_demo.py

class Human:
    """人类"""

    # 类属性
    message = "这是Human的类属性"

    # 构造方法
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 实例方法
    def live(self):
        print("住在地球上")


class Student(Human):
    """学生类"""

    def study(self):
        print("正在学习")


# 实例化子类对象
stu = Student("哈利波特", 12)
# 访问类属性（继承）
print(stu.message)
# 访问实例属性（继承）
print(stu.name, stu.age)
# 访问实例方法（继承）
stu.live()
# 访问实例方法（扩展）
stu.study()

4.3 类型检查

  • isinstance(实例, 类名)
    • 检查对象是否是某个类及其派生类的实例
  • issubclass(类名1, 类名2)
    • 检查类名 1 是否是类名 2 的子类
# relation_demo.py

# 人类
class Human:
    pass

# 学生类
class Student(Human):
    pass

# 老师类
class Teacher(Human):
    pass

# 检查实例与类的关系
stu = Student()
print(isinstance(stu, Human))  # 将会打印 True

# 检查类与类的关系
print(issubclass(Student, Human))  # 将会打印 True
print(issubclass(Student, Teacher))  # 将会打印 False

5. python多态

5.1 多态的概念

多态（Polymorphism）：同名方法呈现多种行为

python弱类型语言，变量并没有声明类型，因此完全可以在不同的时间代表不同的变量，当同一个变量在调用同一个方法时，完全可能呈现出多种行为，具体呈现的哪些行为由该变量所引用的对象来决定。这就是多态。

5.2 多态的表现

5.2.1 运算符的多态表现

  • +号
    • 加法：数字+数字
    • 拼接：字符串+字符串
    • 合并：列表+列表
# 加法：数字+数字
print(1 + 1)  # 打印 2

# 拼接：字符串+字符串
print("Hello" + "World")  # 打印 Hello World

# 合并：列表+列表
print([1, 2] + [3])  # 打印 [1, 2, 3]

5.2.2 函数的多态表现

  • len()函数

    • 可以接收字符串
    • 可以接收列表
# 参数是字符串
print(len("Hogwarts"))

# 参数是列表
print(len([1, 3, 5]))

5.2.3 方法的多态表现

同名变量调用同名方法呈现多种行为。

# poly_method.py

class China:
    def speak(self):
        print("汉语")

class Usa:
    def speak(self):
        print("英语")

# 实例化对象
cn = China()
us = Usa()

for x in (cn, us):
    # 同一个变量在调用同名方法时，呈现不同的行为
    # 具体呈现哪种行为，由该变量所引用的对象决定
    x.speak()

5.3 多态与继承

  • 方法重写（Override）：子类的方法名称与父类的相同
  • 重写构造方法
    • super().__init__()
    • 父类名.__init__(self)
# override_demo.py

class Human:
    """人类"""

    message = "这是Human的类属性"

    # 构造方法
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 实例方法
    def live(self):
        print(f"住在地球上")


class Student(Human):
    """学生类"""

    # 重写父类的构造方法
    def __init__(self, name, age, school):
        # 方式一：访问父类的构造方法
        super().__init__(name, age)
  
        #方式二：访问父类的构造方法
        # super(Student, self).__init__(name, age)

        #方式三：访问父类的构造方法
        # Human.__init__(self, name, age)
   
	# 子类特有的实例属性（个性）
        self.school = school

    # 重写父类的实例方法
    def live(self):
        print(f"住在{self.school}")


# 实例化子类对象
stu = Student("哈利波特", 12, "Hogwarts")

# 访问实例方法
stu.live()  # 将会打印 住在Hogwarts
爱测试的高胖胖
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python之封装、继承、多态
weixin_44118591的博客
07-31 349
目录 封装 继承 继承的基本使用 私有属性的继承特点 新式类和经典类 子类重写父类的方法 多态 Java和python多态使用的不同表现 封装 封装：即打包 函数是对语句的封装 类是对函数和变量的封装 继承 继承的基本使用 什么是继承？ 继承是一种创建新的类的方式，新创建的叫子类，继承的叫父类、超类、基类。 特点：子类可以使用父类的属性（特征、技能） 继承是类与类之间的关系 为什么要使用继承？ 减少代码冗余、提高重用性 继承的使用 单继承 cl...
【python进阶】python中的类、继承、多态
fanc的博客
01-15 198
定义一个python类： class Point: def __init__(self, x = 0, y = 0): self.x, self.y = x, y p = Point(10, 10) print(type(p)) print(p.x, p.y) print(dir(Point)) print(help(Point)) 输出： dir可以打印这个类里面的所...
python面向对象之封装、继承与多态
菜鸟学识的博客
03-17 1100
⾯向对象三⼤特性分别是封装，继承，多态。所谓继承其实就是类与类之间的关系，⽽继承的⽬的就是为了解决代码重⽤问题，所以继承在某些⽅⾯来说，它是⼀种创建新类的⽅式，在Python中，⼀个类可以继承⼀个类，也可以继承多个类。被继承的类被称为:基类，继承别⼈的类，被称为:派⽣类。passpasspasspass执⾏如上的代码后，输出的结果信息为:passpasspass执⾏代码后，输出的结果信息:特别注意:⼦类可以继承⽗类所有的⽅法以及属性。单继承。
Python中的封装、继承与多态（史上最简单易懂版）
Elon15的博客
10-06 3554
Python中的封装、继承与多态（史上最简单易懂版）
Python自动化脚本+关键字封装理念
欢迎来到谷雨飞鱼的博客
10-19 1344
2.6 第一个自动化脚本 这里我们简单写一下百度搜索腾讯课堂的脚本，方法在2.4、2.5章节已经介绍过了，这里就是带看一下代码的实现，到底是怎么写的！如果我们需要其他操作就driver.对应的方法就可以了。 from selenium import webdriver driver=webdriver.Chrome() #注意Chrome的C是大写 driver.implicitly_wait(10) #隐式等待 #访问网址from selenium import webdriver driver=web
【Python面向对象】封装、继承、多态
尹煜的博客
05-02 5216
面向对象有三个基本特征，分别是封装、继承和多态。其中，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用/调用！本文将利用Python语言进行简单举例，以帮助大家更好地理解这三个特征。
Python 接口测试之接口关键字封装
2301_77645750的博客
10-01 158
引言 我们使用RF做UI自动化测试的时候，使用的是关键字驱动。同样，Python做接口自动化测试的时候，也可以使用关键字驱动。但是这里并不是叫关键字驱动，而是叫数据驱动。而接口测试的关键字是什么呢？ 我们数据驱动的载体是Excel，那么excel里存放的数据是接口测试用例数据，一个接口数据里有常量和变量。变量就是一些参数对应的值，而常量就是接口的：host、path、method和data等等。而这些常量是固定不变的，我们可以将接口测试用例这些常量封装到一个类中，每次执行测试的时候，调用类中某个方法来读取e
Python 面向对象之封装、继承、多态操作实例分析
09-18
面向对象编程是Python中的核心概念，它包括三个关键特性：封装、继承和多态。这些特性使得代码更加模块化、可复用和易于维护。 **封装**是面向对象编程的基础，它涉及将数据和操作数据的方法绑定在一起，形成一个...
Python类继承和多态原理解析
12-20
这篇文章主要介绍了python类继承和多态原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 现在属于是老年人的脑子，东西写着写着就忘了，东西记着记着就...
Python面向对象程序设计多继承和多态用法示例
09-19
面向对象编程是Python中一个重要的概念，它允许我们通过类和对象来组织代码，提高代码的复用性和可维护性。本篇将深入探讨Python中的...在实际应用中，结合类的封装、继承和多态，可以构建出高效、可读性强的代码结构。
第十二章Python继承和多态习题与答案--中文
12-29
第十二章Python继承和多态习题与答案--中文
python(封装、继承、多态)_.mp4
04-11
面向对象的三大特性是指:封装、继承和多态。 Python3 面向对象 Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象
Python学习之封装、继承、多态详解
一个野生自学的运维狗
05-16 2475
面向对象的三大特征 封装 如何隐藏一个对象中的屈性?如何获取对急中的属性? 继承 定义一个类Animal(动物》这个类中需要两个方法:run( sleepO定义一个类Dog(狗)这个类中需要三个方法: run () sleep( barks[)issubclass()检查—个类是否是另一个类的了类 重写 多重继承 鸭子类型 len0
四、Python三大特性：封装、继承、多态
weixin_46190208的博客
04-05 3459
1.Python三大特性：封装、继承、多态 1.1 封装 ​ 是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现内部的操作和访问；本质上来将我们只需要调用封装提供的接口，无须关系类内部实现； 1.2 继承 ​ 继承的主要目的是实现代码的复用，既子类可以继承来一个或多个父类的方法或属性 1.3 多态 ​ 多态是指向同一个方法的调用由于对象不同可能产生不同的行为 ​ 多态存在的两个必要条件：继承和方法重写 #封装 class Animal: de
python编程基础(五): 面向对象--封装、继承
热门推荐
天狼啸月1990的博客
08-24 1万+
class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧着着是(object)，表示该类从哪个类继承下来。如果没有合适的继承类，就使用object，这是所有类最终都会继承的类。定义好了Student类，就可以根据Student类创建出Student实例，创建instance是通过类名+()实现的。由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__(分别有两根下划线。
Python封装、继承和多态
Charge8的博客
02-04 1576
Python封装、继承和多态
【Python】类的封装、继承 & 多态
Superman_H的博客
09-03 392
类的封装、继承 & 多态类的基本使用类的封装封装的操作装饰器的使用装饰器@property装饰器@函数名 . setter装饰器@函数名 . deleter类的继承继承的操作issubclass(class1, class2)className . __ bases __super(Class, self) 函数单继承多继承类的多态对象之间没有继承关系的情况对象之间有继承关系的情况 类的基本使用 类的封装 封装的操作 用于设置对象中的私有数据(属性) / 行为(方法)，使其不能被修改。 在定义类时
【Python】在 VS Code 里面绘制动图不显示动画的解决办法
最新发布
Suasy小易的博客
06-25 417
VS Code 中使用 matplotlib 的动画功能，需要配置适当的绘图后端。
python封装继承和多态
03-25
Python中的封装、继承和多态是面向对象编程的重要概念。下面我将为你介绍一下它们： 1. 封装（Encapsulation）： 封装是将数据和对数据的操作封装在一个类中，通过定义类的属性和方法来实现。封装可以隐藏类的内部...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值