Python学习笔记--5.（封装、继承、多态）Python面向对象编程介绍及其三大特性

最新推荐文章于 2023-02-07 11:52:36 发布

Rabbitgo_hyl

最新推荐文章于 2023-02-07 11:52:36 发布

阅读量251

点赞数

分类专栏： python学习文章标签： python 面向对象编程封装继承多态

本文链接：https://blog.csdn.net/weixin_45233090/article/details/118059733

版权

python学习专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Python学习笔记--5.Python面向对象编程三大特性（封装、继承、多态）

前言
一、python基础知识回顾
二、面向对象编程介绍（了解）
三、面向对象编程三大特性（重点）
四、项目案例：栈和队列的封装
笔记补充

前言

本章我们将学习全新的python进阶学习，面向对象编程。在对前面基础知识的简单回顾后、将通过类（class）、对象（object）学习python面向对象编程的三大特性——封装、继承、多态。

一、python基础知识回顾

1.开发工具：python解释器、pycharm

2.数据类型：

数值类型: int ,float, bool, complex（复数）

字符串str：‘hello’
元组tuple和列表list：
元组不可增删改查
集合set和字典dict
集合：无序不重复，可用于去重

3.输入与输出
输入：input() ，读入文件内容
输出：print()，导出为文件

4.函数
def 函数名（参数）:
函数体
return 返回值
result = 函数名（参数）

面试常见问题 *args：可变参数（元组） **kwargs ：关键字参数（字典）是什么？

二、面向对象编程介绍（了解）

面向过程编程：以过程为中心的编程思想，eg：C C++
特点：
按照需求，一步一步完成
模块化（一步一步完成）、流程化（一步一步执行）
优点：性能高，因为调用类开销非常大，
缺点：可维护性差。不易复用，不易扩展

在这里插入图片描述

函数式编程：
把运算过程尽量写成一系列嵌套的函数调用，把函数作为输入输出
eg：装饰器

面向对象编程：
特性：抽象封装继承多态
优点：可复用、可扩展、可维护性高、系统更灵活
缺点：性能比面向对象低

三、面向对象编程三大特性（重点）

为什么好维护好拓展？

类（Class）是现实或思维中的实体在计算机中的反映，是个模板。
对象（Object）是具体类型。
类和对象是面向对象编程技术的最基本概念。
eg、鱼和三文鱼、猫和蓝猫

属性：通常是个名词

python开发规范PEP8
首字母大写，驼峰式命名法： StudentCount
所以：
类是创建实例的模板
对象是面向类的一个个实例

class People:
    country = 'china'
    city = "xi'an"

    def __init__(self, name, age):
        print('正在执行构造方法.....')
        print('self:', self)
        self.name = name  # self.name就是将对象和属性绑定在一起的过程
        self.age = age

    def coding(self):
        print('%s正在编程中......' % (self.name))
# 封装
# 对象object(实例化对象)
p1 = People(name='张三', age=18)
print('p1:', p1)
print(p1.name, p1.age)
p1.coding()

在这里插入图片描述

三大特性：封装、继承和多态

封装

封装
1）将内容封装到某处
2）从某处调用封装内的内容

__ init__：构造方法，与普通的方法不同，会自动执行（在实例化对象的时候）

   def __init__(self, name, age):
        print('正在执行构造方法.....')
        print('self:', self)
        self.name = name  # self.name就是将对象和属性绑定在一起的过程
        self.age = age

self是什么？
实例化的对象，（self）中的self是形参

封装： 将对象和属性绑在一起
self.attribute = ‘xxxx’

使用封装的内容：
self.attribute
obj.name.attribute

debug代码即可查看特性

总结：
面向对象的封装，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或self间接获取被封装的内容。

继承

继承
多继承
私有属性与私有方法

继承

继承描述的是事物之间的所属关系，当我们定义一个class的时候,可以从某个现有的class 继承。

子类、扩展类

# 子类ComputerStudent继承Student父类
class ComputerStudent(Student):
    def get_grade(self):
        if 70 <= self.score <= 100:
            return 'A'
        else:
            return 'B'

父类、基类

# 父类(基类)
class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

函数中，pass 用于占位

如何实现继承：()中写上父类
怎么继承：自己有方法执行自己的，自己没有方法执行父类的

调用父类的方法：

super(ComputerStudent, self).learning() ##找到ComputerStudent的父类，执行父类的learning方法

父类：

# 父类(基类)
class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def get_grade(self):
        if 90 <= self.score <= 100:
            return 'A'
        else:
            return 'B'

    def learning(self):
        print('每天早上8：00-18：00开始学习')

子类：

def learning(self):
    # 3). 调用父类的方法：找到ComputerStudent的父类，执行父类的learning方法
    super(ComputerStudent, self).learning()
    print('   - 操作系统')
    print('   - 计算机网络')
    print('   - 计算机组成')
    print('   - 数据结构与算法')

# 子类MathStudent继承Student父类
class MathStudent(Student):
    def learning(self):
        # 3).调用父类的方法：找到MathStudent的父类，执行父类的learning方法
        super(MathStudent, self).learning()
        print('   - 高等数学')
        print('   - 线性代数')

调用：

# 1). 继承规则： 自己有get_grade方法执行自己的get_grade方法
s1 = ComputerStudent('李四', 80)
print(s1.get_grade())  # A
s1.learning()
# print(s1.aa())   # 不会执行

# 2). 继承规则： 自己没有get_grade方法执行父类的get_grade方法
s1 = MathStudent('张三', 80)
print(s1.get_grade())  # B
# print(s1.aa())   # 不会执行
s1.learning()

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

私有属性、私有方法

私有属性：
只有类的内部可以访问、子类也不可以、只能通过函数简介调用

self.__score = score  # 1). 私有属性

私有方法：

def __play_game(self):  # 3). 私有方法
    print('正在玩游戏')

私有方法也只能内部调用，外部统统不可以调用

s = Student(name='张三', score=100)
print(s.get_grade())
# print(s.__score)     # 1). 类的外部不可以访问私有属性
s.set_score(80)
print(s.get_grade())  # 2). 如果想要修改私有属性，可以提供方法set_score在类的内部修改

在这里插入图片描述

多继承：子类有多个父类

python2：新式类和经典类（现已停用）
经典类：深度优先算法不指定就是经典类
新式类：广度优先算法指定类名就是新式类

python3：都是新式类、继承时遵循广度优先算法

多态

多态特性：“多种状态”，不同对象执行同一方法执行结果是完全不同的
上个例子中、计算机学生和数学学生执行learning结果不同。

四、项目案例：栈和队列的封装

队列封装
需求：
队列是限制在一端进行插入操作和另一端删除操作的线性表，允许进行插入操作的一端称为“队尾”，允许进行删除操作的一端称为“队头”，，当队列中没有元素时称为“空队”。特点：先进先出（FIFO）。
在这里插入图片描述

class Queue(object):
    """以list为基础封装队列数据结构"""

    def __init__(self):
        # []左侧队头只能弹出，右侧队尾只能添加
        self.queue = []

    def enqueue(self, val):
        """入队"""
        self.queue.append(val)

    def dequene(self):
        """出队"""
        if self.is_empty():
            return 'error'
        item = self.queue.pop(0) # pop是内置函数 即弹出第一个队头元素
        return item

    def is_empty(self):
        """判断栈是否为空"""
        return len(self.queue) == 0

    def top(self):
        """获取队头元素"""
        if self.is_empty():
            return 'error'
        return self.queue[0]

    def __len__(self):
        """获取队内元素"""
        # 魔术方法,当执行len(obj)自动执行的方法
        # 拓展(魔术方法):http://c.biancheng.net/view/7817.html
        return len(self.queue)

    # def __str__(self):
    #     return ",".join([str(i) for i in self.queue])
# print(str(s))

Q = Queue()
Q.enqueue(7)
Q.enqueue(6)
print(len(Q))
print(Q.is_empty())
# Q.dequene()
print(Q.top())

部分执行结果：
在这里插入图片描述

笔记补充

pycharm中批量替换
ctrl+r ----> 输入替换前和替换后的词，点击replace

Rabbitgo_hyl

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
Python学习笔记--5.（封装、继承、多态）Python面向对象编程介绍及其三大特性

Python学习笔记--5.Python面向对象编程三大特性（封装、继承、多态）前言一、python基础知识回顾二、面向对象编程介绍（了解）三、面向对象编程三大特性（重点）封装继承继承私有属性、私有方法多态四、项目案例：栈和队列的封装笔记补充前言本章我们将学习全新的python进阶学习，面向对象编程。在对前面基础知识的简单回顾后、将通过类（class）、对象（object）学习python面向对象编程的三大特性——封装、继承、多态。一、python基础知识回顾1.开发工具：python解释器、p
复制链接

扫一扫