Python学习笔记--5.（封装、继承、多态）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