一、面向过程编程语言

“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。分析出解决问题所需要的步
骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象的方法也是含有面向过程的思想。面向过程最重要的是模块化的思想方
法。比如拿学生早上起来这件事说明面向过程，粗略的可以将过程拟为：
(1)起床
(2)穿衣
(3)洗脸刷牙
(4)去学校
而这4步就是一步一步地完成，它的顺序很重要，你只需要一个一个地实现就行了。
而如果是用面向对象的方法的话，可能就只抽象出一个学生的类，它包括这四个
方法，但是具体的顺序就不一定按照原来的顺序。

特性：
模块化流程化
优点：
性能比面向对象高, 因为类调用时需要实例化，开销比较大，比较消耗资源;
单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：
没有面向对象易维护、易复用、易扩展

二、函数式编程语言

函数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ
演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。
主要思想: 把运算过程尽量写成一系列嵌套的函数调用。

三、面向对象编程语言

面向对象是按人们认识客观世界的系统思维方式，把构成问题事务分解成各个对象，建立对
象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

特性：抽象封装继承多态
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，
可以设计出低耦合的系统，使系统更加灵活、更加易于维护
缺点：性能比面向过程低

1 . 类和对象

类（Class）是现实或思维世界中的实体在计算机中的反映，它将数据以及这些数
据上的操作封装在一起。
对象(Object)是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概
念

如何定义类? class 类(): pass
如何将类转换成对象?
实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概
念类，具体到该类实物的过程。实例化过程中一般由类名对象名 = 类名（参数1，参数2…参数n）
构成。

# 类（Class）
class Cat:# 属性:一般是名词，eg：name,age,gender....name = 'name'kind = 'kind'# 方法：一般情况是动词，eg:create,delete,eating,run...def eat(self):print('cat like eating fish...')
#对象（Object）:对类得实例化（具体化）
jiongjiong = Cat()print(Cat)   #<class '__main__.Cat'>
print(jiongjiong)   #<__main__.Cat object at 0x000001E5D1684B50>

类（Class）是是创建实例的模板
对象(Object)是一个一个具体的实例

2 . 封装特性

面向对象的三大特性是指：封装、继承和多态

(1)封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：
1). 将内容封装到某处
2). 从某处调用被封装的内容
1). 通过对象直接调用被封装的内容：对象.属性名
2). 通过self间接调用被封装的内容： self.属性名
3). 通过self间接调用被封装的内容: self.方法名()

构造方法__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调
用构造方法。自动执行构造方法里面的内容。
对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过
对象直接或者self间接获取被封装的内容。

# 类(Class)
class Cat:def __init__(self, name, kind):  # 形参"""1. 构造方法，实例化对象时自动执行的方法2. self是什么? self实质上是实例化的对象3. 类方法中, python解释器会自动把对象作为参数传给self"""print('正在执行__init__构造方法')print('self:', self)# 属性：一般是名词，eg: name, age, gender.....# 封装: self.name将对象和name属性封装/绑定self.name = nameself.kind = kind# 方法: 一般情况是动词, eg: create, delete, eating, run......def eat(self):print('cat %s like eating fish.....' %(self.name))# 对象(Object):对类的实例化(具体化)
jiongjiong = Cat("囧囧", "美短虎斑")
print(jiongjiong.name)
print(jiongjiong.kind)
jiongjiong.eat()

代码运行结果：

创建一个类People,拥有的属性为姓名，性别和年龄，拥有的方法为购物,玩游戏,学习;实例化
对象,执行相应的方法。显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,20岁,男,去西安赛格购物广场购物
小红,22岁,女,在西部开源学习
提示:
属性:name,age,gender
方法:shopping(), playGame(), learning()

"""
创建一个类People,拥有的属性为姓名， 性别和年龄， 拥有的方法为购物,玩游戏,学习;实例化
对象,执行相应的方法。 显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,20岁,男,去西安赛格购物广场购物
小红,22岁,女,在西部开源学习
提示:
属性:name,age,gender
方法:shopping(), playGame(), learning()
"""
class People:def __init__(self,name,age,gender):self.name = nameself.age = ageself.gender = genderdef shopping(self):print(f'{self.name},{self.age}岁，{self.gender}，去西安赛格购物广场购物')def learning(self):print(f'{self.name},{self.age}岁,{self.gender},在西部开源学习')
p1 = People('小明','18','男')
p2 = People('小王','20','男')
p3 = People('小红','22','女')p1.shopping()
p2.shopping()
p3.learning()

代码运行结果：

3 . 继承特性

面向对象的三大特性是指：封装、继承和多态

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

继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、
Superclass)。

问题一: 如何让实现继承?
子类在继承的时候,在定义类时,小括号()中为父类的名字
问题二: 继承的工作机制是什么?
父类的属性、方法,会被继承给子类。举例如下: 如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法

class Student:def __init__(self,name,age):self.name = nameself.age = agedef learning(self):print(f'{self.name}正在学习')
class MathStudent(Student):"""MathStudent的父类是student"""pass#实例化
m1 = MathStudent('华罗庚',88)
print(m1.name)
print(m1.age)
m1.learning()    #子类没有就会去父类找
# m1.choice_course()  #子类和父类都没有就会报错

代码运行结果：

4 . 重写父类方法

就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法。

class Student:def __init__(self,name,age):self.name = nameself.age = agedef learning(self):print(f'{self.name}正在学习')def choice_course(self):print('正在选课中'.center(50,'*'))class MathStudent(Student):"""MathStudent的父类是student"""def choice_course(self):# 需求：先执行父类的方法choice_course，再个性化执行自己的方法#Student.choice_course(self)  #方法1：直接执行父类的方法，但不建议#方法2：通过super找到父类的方法，再执行（）中的。super(MathStudent,self).choice_course()info = """课程表1. 高数2. 线性代数3. 概率论"""print(info)#实例化
m1 = MathStudent('华罗庚',88)
m1.choice_course()

代码运行结果：

5 . 练习

两数相加力扣网址

直接在力扣上做,代码如下：

#Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:res = 0l3 = ListNode()cur = l3while(l1 or l2):if(l1):res += l1.val  # res=2l1 = l1.nextif(l2):res += l2.val # res=2+5=7l2 = l2.next# res=10, val=0, res=>val val=res%10# res=14, val=4, 14%10=4l3.next = ListNode(res%10)l3 = l3.next# res=10, 进位为1， 10//10=1# res=14, 进位为1， 14//10=1res  //= 10if res == 1:l3.next = ListNode(1)return cur.next

6 . 链表的封装

"""
参考链接 https://www.cnblogs.com/klyjb/p/11237361.html
数组: 需要连续的内存空间
链表: 不需要连续的内存空间数组              链表
增加元素        O(n)                O(1)
删除元素        O(n)                O(1)
修改元素        O(1)                O(n)
查看元素        O(1)                O(n)
"""# 封装节点类
class ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef travel(self, head):"""遍历链表里面的每一个元素"""while head:print(head.val, end=',')head = head.nextdef create_l1():# l1 = 2,4,3# l2 = 5, 6, 4l1 = ListNode()node1 = ListNode(val=2)node2 = ListNode(val=4)node3 = ListNode(val=3)l1.next = node1node1.next = node2node2.next = node3return  l1.nextdef create_l2():# l1 = 2,4,3# l2 = 5, 6, 4l2 = ListNode()node1 = ListNode(val=5)node2 = ListNode(val=6)node3 = ListNode(val=4)l2.next = node1node1.next = node2node2.next = node3return  l2.nextdef addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode:res = 0l3 = ListNode()cur = l3while(l1 or l2):if(l1):res += l1.val  # res=2l1 = l1.nextif(l2):res += l2.val # res=2+5=7l2 = l2.next# res=10, val=0, res=>val val=res%10# res=14, val=4, 14%10=4l3.next = ListNode(res%10)l3 = l3.next# res=10, 进位为1， 10//10=1# res=14, 进位为1， 14//10=1res  //= 10if res == 1:l3.next = ListNode(1)return cur.nextif __name__ == '__main__':l1 = create_l1()l2 = create_l2()l3 = addTwoNumbers(l1, l2)l3.travel(l3)

7. 多继承

多继承,即子类有多个父类,并且具有它们的特征

在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式
类”
，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类，
则称之为“经典类”。

“新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。
最明显的区别在于继承搜索的顺序不同，即：
经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找，然后再返回，开始查找右侧。
新式类多继承搜索顺序(广度优先算法):先在水平方向查找，然后再向上查找，

"""
新式类: 广度优先算法
经典类： 深度优先算法(py2中的部分类属于经典类)python3所有的类都属于新式类。新式类的继承算法是广度优先。# 分析多继承的相关代码
>pip install djangorestframework
from rest_framework import viewsets
viewsets.ModelViewSet
"""class D(object):def hello(self):print('D')
class C(D):# def hello(self):#     print('C')pass
class B(D):pass# def hello(self):#     print('B')
class A(B, C):pass# def hello(self):#     print('A')
a = A()
a.hello()

四、私有属性和私有方法

默认情况下,属性在 Python 中都是“public”，大多数 OO 语言提供“访问控制符”来限定成员函数的访问。
在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性
(private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只
有内部可以访问,外部不能访问。

class Student:"""父类Student"""def __init__(self, name, age, score):self.name = nameself.age = age# 私有属性，以双下划线开头。# 工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。self.__score = scoredef learning(self):print(f'{self.name}正在学习')def get_score(self):self.__modify_score()return  self.__score# 私有方法是以双下划线开头的方法,#工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。def __modify_score(self):self.__score += 20class MathStudent(Student):"""MathStudent的父类是Student"""def get_score(self):self.__modify_score()return  self.__score# 报错原因: 子类无法继承父类的私有属性和私有方法。
s1 = MathStudent('张三', 18, 100)
score = s1.get_score()
print(score)

优势

确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护, 代码更加健壮。
如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方
法。为什么大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。

五、多态特性

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。通俗来说：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：
对扩展开放（Open for extension）：允许子类重写方法函数
对修改封闭（Closed for modification）：不重写，直接继承父类方法函数

python面向对象编程(封装与继承)相关推荐

python面向对象编程 -- 封装、继承
面向对象编程 -- 封装.继承面向对象编程三要素:封装.继承和多态.本文主要看和封装.继承相关的概念:在python中多态的概念比较模糊,本文不做讨论. 1 封装封装:将数据和操作组装到一起,对外 ...
Python面向对象编程：类继承和其衍生术语
Python面向对象编程03:类继承和其衍生术语前面我们讲到过正则表达式字符等,上一篇分享了面向对象编程和类的结构,最后稍微提到了继承. Python面向对象编程:深度认识类class_ Pytho ...
python面向对象之封装、继承与多态
目录面向对象程序设计类和对象属性查找数据属性实例属性类的封装封装数据封装⽅法(隔离复杂度) 类的⽅法类的继承继承概述单继承多继承⽅法重写继承原理深度优先&⼴度优先 ...
javascript 面向对象编程(封装、继承)
在面向对象编程中,类(class)是对象(object)的模板,定义了同一组对象(又称"实例")共有的属性和方法. Javascript语言不支持"类",但是可 ...
Python零基础速成班-第9讲-Python面向对象编程(上)，对象和类、初始化、继承、重写、多态、类方法、组合
Python零基础速成班-第9讲-Python面向对象编程(上),对象和类.初始化.继承.重写.多态.类方法.组合学习目标修饰器面向对象编程:对象和类.初始化.继承.重写.多态.类方法.组合课 ...
python对象编程例子-这是我见过最详细的Python面向对象编程！建议收藏！
原标题:这是我见过最详细的Python面向对象编程!建议收藏! 面向对象编程和函数式编程(面向过程编程)都是程序设计的方法,不过稍有区别. 面向过程编程: 1. 导入各种外部库 2. 设计各种全局变量 ...
【Python基础】Python 面向对象编程(上篇)
我的施工计划图已完成专题包括: 1我的施工计划 2数字专题 3字符串专题 4列表专题 5流程控制专题 6编程风格专题 7函数使用专题今天是面向对象编程的上篇:基础专题 Python 面向对象编程 ...
python面向对象编程138讲_Python面向对象编程简单讲解
学习目标: 1-面向对象编程 2-类和对象 3-对象的属性和方法 4-类的特性 Python面向对象编程一种编程程序的设计思想,把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数.把计算机 ...
（转）Python 面向对象编程（一）
Python 面向对象编程(一) 虽然Python是解释性语言,但是它是面向对象的,能够进行对象编程.下面就来了解一下如何在Python中进行对象编程. 一.如何定义一个类在进行python面向对象 ...

python面向对象编程(封装与继承)

一、面向过程编程语言

二、函数式编程语言

三、面向对象编程语言

1 . 类和对象

2 . 封装特性

3 . 继承特性

4 . 重写父类方法

5 . 练习

6 . 链表的封装

7. 多继承

四、私有属性和私有方法

优势

五、多态特性

python面向对象编程(封装与继承)相关推荐

最新文章

热门文章

python面向对象编程(封装与继承)

一、 面向过程编程语言

二、 函数式编程语言

三、面向对象编程语言

1 . 类和对象

2 . 封装特性

3 . 继承特性

4 . 重写父类方法

5 . 练习

6 . 链表的封装

7. 多继承

四、私有属性和私有方法

优势

五、多态特性

python面向对象编程(封装与继承)相关推荐

最新文章

热门文章

一、面向过程编程语言

二、函数式编程语言