文章目录
1.简介
1.1 编程类型:
- 面向过程编程(按行执行,在此之前的几章)
- 函数式编程
- 面向对象编程:以过程为中心的编程思想。分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。
1.2 特征及优缺点
特征: 抽象 封装 继承 多态
优点: 易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,
可以设计出低耦合 的系统,使系统更加灵活、更加易于维护
缺点: 性能比面向过程低
2.面向对象编程的三大特性
面向对象的三大特性是指:封装、继承和多态
2.1 类和对象
类(Class) 是现实或思维世界中的实体在计算机中的反映,它将数据以及这些数据上的操作封装在一起。
对象(Object) 是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。
# 类(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):对类的实例化(具体化)
fentiao = Cat()
print(Cat)
print(fentiao) #结果为,fentiao是基于Cat创造的一个类
- “_main_” 表示在当前文件中
- 类(class)包括属性部分,方法部分 和用来实例化的对象部分(object),属性部分需要传入
若要将类转化为对象:
实例化是指在面向对象的编程中,把用类创建对象的过程称为实例化。是将一个抽象的概念类,具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名(参数1,参数2…参数n)构成。
即:
类(Class) 是是创建实例的模板
对象(Object) 是一个一个具体的实例
2.2 封装特性
2.2.1 封装
顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。
所以,在使用面向对象的封装特性时,需要:
- 将内容封装到某处
- 从某处调用被封装的内容:
– 通过对象直接调用被封装的内容: 对象.属性名
– 通过self间接调用被封装的内容: self.属性名
– 通过self间接调用被封装的内容: self.方法名()
2.2.2 构造方法
__init__与其他普通方法不同的地方在于,当一个对象被创建后,会立即调用构造方法。自动执行构造方法里面的内容。
# 类(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 = name
self.kind = kind
# 方法: 一般情况是动词, eg: create, delete, eating, run......
def eat(self):
print('cat %s like eating fish.....' %(self.name))
# 对象(Object):对类的实例化(具体化)
fentiao = Cat("粉条", "美短虎斑")
print(fentiao.name)
print(fentiao.kind)
fentiao.eat()
- "def _init_()"该模式自定义的函数会在调用该大类的时候自动执行
- 对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过
对象直接或者self间接获取被封装的内容。
2.2.3 巩固封装特性:
创建一个类People,
拥有的属性为姓名, 性别和年龄,
拥有的方法为购物,玩游戏,学习;
实例化 对象,执行相应的方法。
显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,22岁,男,去西安赛格购物广场购物
小红,10岁,女,在西部开源学习
提示:
属性:name,age,gender
方法:shopping(), playGame(), learning()
class People:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def 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('小王', 22, '男')
p3 = People('小红', 10, '女')
p1.shopping()
p2.shopping()
p3.learning()
属性一般写在def _init_()中
先给类赋值:p1 = People('小明', 18, '男')
再具体调用类下的具体对象:p1.shopping()
2.3 继承特性
面向对象的三大特性是指:封装、继承和多态
- 继承
- 多继承
- 私有属性与私有方法
2.3.1 继承
继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class
继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。
实例:
class Student:
"""父类Student"""
def __init__(self, name, age):
self.name = name
self.age = age
def learning(self):
print(f'{self.name}正在学习')
class MathStudent(Student):
"""MathStudent的父类是Student"""
pass
# 实例化
m1 = MathStudent("粉条博士", 8)
print(m1.name)
print(m1.age)
m1.learning() # 不报错,子类里没有,但父类有该方法
# m1.choice_course() # 报错, 子类里没有,父类也没有的方法
重写父类方法:
class Student:
"""父类Student"""
def __init__(self, name, age):
self.name = name
self.age = age
def 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("粉条博士", 8)
m1.choice_course()
s1 = Student("粉条博士", 8)
s1.choice_course()
巩固练习——链表的封装:
参考链接 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 = val
self.next = next
def travel(self, head):
"""遍历链表里面的每一个元素"""
while head:
print(head.val, end=',')
head = head.next
def create_l1():
# l1 = 2,4,3
# l2 = 5, 6, 4
l1 = ListNode()
node1 = ListNode(val=2)
node2 = ListNode(val=4)
node3 = ListNode(val=3)
l1.next = node1
node1.next = node2
node2.next = node3
return l1.next
def create_l2():
# l1 = 2,4,3
# l2 = 5, 6, 4
l2 = ListNode()
node1 = ListNode(val=5)
node2 = ListNode(val=6)
node3 = ListNode(val=4)
l2.next = node1
node1.next = node2
node2.next = node3
return l2.next
def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode:
res = 0
l3 = ListNode()
cur = l3
while(l1 or l2):
if(l1):
res += l1.val # res=2
l1 = l1.next
if(l2):
res += l2.val # res=2+5=7
l2 = l2.next
# res=10, val=0, res=>val val=res%10
# res=14, val=4, 14%10=4
l3.next = ListNode(res%10)
l3 = l3.next
# res=10, 进位为1, 10//10=1
# res=14, 进位为1, 14//10=1
res //= 10
if res == 1:
l3.next = ListNode(1)
return cur.next
# 中午留个作业:查一下它的功能
if __name__ == '__main__':
l1 = create_l1()
l2 = create_l2()
l3 = addTwoNumbers(l1, l2)
l3.travel(l3)
- def travl(self,head)函数用来遍历链表中的所有节点,控制部分为head.next跳转至下一节点
- 链表在内存空间中的储存形式和数组不同,链表中的每一个元素包含元素及下一个元素的内存id,在内存中并不是连续的
- print(,end=",")使得打印内容不换行,以逗号隔开
- 20//10=2,//为整除的意思
- python文件通常有两种使用方法,第一是作为脚本直接执行,第二是 import 到其他的 python 脚本中被调用(模块重用)执行。因此 if _name_ == ‘main’: 的作用就是控制这两种情况执行代码的过程,在 if _name_ == ‘main’: 下的代码只有在第一种情况下(即文件作为脚本直接执行)才会被执行,而 import 到其他脚本中是不会被执行的。
2.3.2 多继承
多继承,即子类有多个父类,并且具有它们的特征
- 在Python 2及以前的版本中,由任意内置类型派生出的类,都属于“新式类”,都会获得所有“新式类”的特性;反之,即不由任意内置类型派生出的类,则称之为“经典类”。
- “新式类”和“经典类”的区分在Python 3之后就已经不存在,在Python 3.x之后的版本,因为所有的类都派生自内置类型object(即使没有显示的继承object类型),即所有的类都是“新式类”。
- 最明显的区别在于继承搜索的顺序不同,即:经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找,然后再返回,开始查找右侧;新式类多继承搜索顺序(广度优先算法):先在水平方向查找,然后再向上查找
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()
新式类: 广度优先算法
经典类: 深度优先算法(py2中的部分类属于经典类)
python3所有的类都属于新式类。新式类的继承算法是广度优先。
分析多继承的相关代码:
pip install djangorestframework
from rest_framework import viewsets
viewsets.ModelViewSet
2.3.3 私有属性与私有方法
- 默认情况下,属性在 Python 中都是“public”, 大多数 OO 语言提供“访问控制符”来限定成员函数的访问。
- 在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性(private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只有内部可以访问,外部不能访问。
创立私有的目的:
- 确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。
- 如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方法。 为什么大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。
class Student:
"""父类Student"""
def __init__(self, name, age, score):
self.name = name
self.age = age
# 私有属性,以双下划线开头。
# 工作机制: 类的外部(包括子类)不能访问和操作,类的内部可以访问和操作。
self.__score = score
def learning(self):
print(f'{self.name}正在学习')
def get_score(self):
self.__modify_score()
return self.__score
# 私有方法是以双下划线开头的方法,
#工作机制: 类的外部(包括子类)不能访问和操作,类的内部可以访问和操作。
def __modify_score(self):
self.__score += 20
class MathStudent(Student):
"""MathStudent的父类是Student"""
def get_score(self):
self.__modify_score()
return self.__score
# 报错原因: 子类无法继承父类的私有属性和私有方法。
s1 = MathStudent('张三', 18, 100)
score = s1.get_score()
print(score)
- 私有属性(指在定义的函数内部的变量,例如self.__score)必须在内部定义一个端口返回值,才能在函数外部通过返回值拿到结果
- 私有方法(指在类中定义的函数,例如def __modify_score(self))
- 私有类不能继承给子类使用
2.4 多态特性
多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。通俗来说: 同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。
多态的好处就是,当我们需要传入更多的子类,只需要继承父类就可以了,而方法既可以直接不重写(即使用父类的),也可以重写一个特有的。这就是多态的意思。调用方只管调用,不管细节,而当我们新增一种的子类时,只要确保新方法编写正确,而不用管原来的代码。这就是著名的“开闭”原则:
- 对扩展开放(Open for extension):允许子类重写方法函数
- 对修改封闭(Closed for modification):不重写,直接继承父类方法函数
2.5 封装案例(栈,队列,二叉树)
2.5.1 栈的封装
栈是限制在一端进行插入操作和删除操作的线性表(俗称堆栈),允许进行操作的一端称为“栈顶”,
另一固定端称为“栈底”,当栈中没有元素时称为“空栈”。向一个栈内插入元素称为是进栈,push;
从一个栈删除元素称为是出栈,pop。特点 :后进先出(LIFO)。
需求:
class Stack(object):
"""栈的封装[1, 2, 3, 4]"""
def __init__(self):
self.stack = []
def push(self, value):
"""入栈"""
self.stack.append(value)
print(f"入栈元素为{value}")
def pop(self):
"""出栈"""
if self.is_empty():
raise Exception("栈为空")
item = self.stack.pop()
print(f"出栈元素为{item}")
return item
def is_empty(self):
"""判断栈是否为空"""
return len(self.stack) == 0
def top(self):
"""返回栈顶元素"""
if self.is_empty():
raise Exception("栈为空")
return self.stack[-1]
def __len__(self):
"""魔术方法, len(object)自动执行的方法"""
return len(self.stack)
if __name__ == '__main__':
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(len(stack)) # 3
stack.pop()
print(stack.is_empty()) # False
print(stack.top()) # 2
2.5.2 队列的封装
队列是限制在一端进行插入操作和另一端删除操作的线性表,允许进行插入操作的一端称为“队尾”,
允许进行删除操作的一端称为“队头”,,当队列中没有元素时称为“空队”。特点 :先进先出(FIFO)。
需求:
class Queue(object):
"""
队列的封装
1. 列表的左侧队尾
2. 列表的右侧队头
"""
def __init__(self):
self.queue = []
def enqueue(self, value):
"""入队"""
self.queue.insert(0, value)
print("入队元素为:", value)
def dequeue(self):
"""出队"""
if self.is_empty():
raise Exception("队列为空")
item = self.queue.pop()
print("出队元素:", item)
return item
def __len__(self):
"""获取队列的长度"""
return len(self.queue)
def first(self):
"""获取队头元素"""
if self.is_empty():
raise Exception("队列为空")
return self.queue[-1]
def last(self):
"""获取队尾元素"""
if self.is_empty():
raise Exception("队列为空")
return self.queue[0]
def is_empty(self):
"""判断队列是否为空"""
return len(self.queue) == 0
if __name__ == '__main__':
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print(queue.is_empty()) # False
queue.dequeue() # 1出队, 队列只剩32
print(queue.first()) # 2
print(queue.last()) # 3
- 队列同样是基于列表来实现
__len__(self)
可以自动获得长度self.queue.insert(0, value)
insert函数可以指定位置和传入的参数- 以列表为例时,利用pop()函数踢出最后一个元素的特征,所以将对头设为列表的队尾
raise Exception("队列为空")
raise函数可以定义报错时显示的内容return len(self.queue) == 0
返回判断时,调用显示布尔类型
2.5.3 二叉树的封装
二叉树(Binary tree)是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式,即使是一般的树也能简单地转换为二叉树,而且二叉树的存储结构及其算法都较为简单,因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树,且有左右之分 。
二叉树是n个有限元素的集合,该集合或者为空、或者由一个称为根(root)的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成,是有序树。当集合为空时,称该二叉树为空二叉树。在二叉树中,一个元素也称作一个结点 。
"""
二叉树:
https://www.cnblogs.com/polly333/p/4740355.html
"""
class Node(object):
"""节点类"""
def __init__(self, val=None, left=None, right=None):
self.val = val
self.left = left
self.right = right
class BinaryTree(object):
"""封装二叉树"""
def __init__(self, root):
self.root = root
def pre_travel(self, root):
"""先序遍历: 根左右"""
if (root != None):
print(root.val)
self.pre_travel(root.left)
self.pre_travel(root.right)
def in_travel(self, root):
"""中序遍历: 左根右"""
if (root != None):
self.in_travel(root.left)
print(root.val)
self.in_travel(root.right)
def last_travel(self, root):
"""后序遍历: 左右根"""
if (root != None):
self.last_travel(root.left)
self.last_travel(root.right)
print(root.val)
if __name__ == '__main__':
node1 = Node(1)
node2 = Node(2)
node3 = Node(3)
node4 = Node(4)
node5 = Node(5)
node6 = Node(6)
node7 = Node(7)
node8 = Node(8)
node9 = Node(9)
node10 = Node(10)
bt = BinaryTree(root=node1)
node1.left = node2
node1.right = node3
node2.left = node4
node2.right= node5
node3.left = node6
node3.right = node7
node4.left = node8
node4.right = node9
node5.left = node10
# 先序遍历
bt.pre_travel(node1)
3. 面向对象的高级特性
3.1 类属性与实例属性
类属性就是类对象所拥有的属性,它被所有类对象的实例对象所共有,在内存中只存在一个副本。
在前面的例子中我们接触到的就是实例属性(对象属性),它不被所有类对象的实例对象所共有,在内存中的副本个数取决于对象个数。
3.2 类方法与静态(实例)方法
类方法是类对象所拥有的方法,需要用修饰器一般以@classmethod来标识其为类方法,
- 对于类方法,第一个参数必须是类对象,作为第一个参数(cls是形参, 可以修改为其它变量名,但最好用’cls’)
- 能够通过实例对象和类对象去访问
class date(object):
# 正常的方法: 将对象作为参数传给self
def get_self(self):
print('self:', self)
# 类方法: 将类名作为参数传给cls
@classmethod
def get_cls(cls):
print('cls:', cls)
# 静态方法:不自动传递任何参数
@staticmethod
def get_static(name, age):
print("静态方法", name, age)
d = date()
d.get_self()
d.get_cls()
d.get_static("张三", 18)
静态方法需要用修饰器一般以@staticmethod来标识其为静态方法,
- 静态方法不需要多定义参数
- 能够通过实例对象和类对象去访问。
3.3 property类属性
一种用起来像是使用的实例属性一样的特殊属性,可以对应于类的某个方法。property属性的定义和调用要注意一下几点:
- 定义时,在实例方法的基础上添加 @property 装饰器;并且仅有一个self参数
- 调用时,无需括号
类属性应用需求: 对于京东商城中显示电脑主机的列表页面,每次请求不可能把数据库中的所有内容都显示到页面上,而是通过分页的功能局部显示,所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据 这个分页的功能包括:
1.根据用户请求的当前页和总数据条数计算出 m 和 n
2.根据m 和 n 去数据库中请求数据
class Page(object):
"""
[user1, user2, user3......user100]
page=2, per_page=10
第一页: start=0 end=10
第二页: start=10 end=20
第三页: start=20 end=30
....
第page页: start=(page-1)*per_page end=page*per_page
"""
def __init__(self, page, per_page=10):
self.page = page
self.per_page = per_page
# 类属性: 将类方法变成类属性的过程。
@property
def start(self):
return (self.page-1) * self.per_page
@property
def end(self):
return self.page * self.per_page
if __name__ == '__main__':
goods = ['good'+str(i+1) for i in range(100)]
page = Page(page=10, per_page=3)
print(goods[page.start:page.end])
property属性的有两种方式:
- 装饰器 即:在方法上应用装饰器
- 类属性 即:在类中定义值为property对象的类属性
注意:
- 经典类中的属性只有一种访问方式,其对应被 @property 修饰的方法
- 新式类中的属性有三种访问方式,并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
一个property的简单案例
class date(object):
def __init__(self, year, month, day):
# 私有属性
self.__year = year
self.__month = month
self.__day = day
# 将类方法object.year()转变成类属性object.year, 只是让代码更加简洁而已。
@property
def year(self):
return self.__year
today = date(2021, 2, 27)
print(today.year)
在year()方法前加了@property使得该方法变成了属性,在调用时依旧需要注意私有性,但是由于变成了方法,从而并不需要再加括号,即调用时形式为:today.year
3.4 单例模式
对于系统中的某些类来说,只有一个实例很重要,例如,一个系统中可以存在多个打印任务,但是只能有一个正在工作的任务;一个系统只能有一个窗口管理器或文件系统;一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化,将弹出多个窗口,如果这些窗口显示的内容完全一致,则是重复对象,浪费内存资源;如果这些窗口显示的内容不一致,则意味着在某一瞬间系统有多个状态,与实际不符,也会给用户带来误解,不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要
什么是单例模式?
一个类只能实例化一个对象的设计模式称为单例模式。
class People(object):
pass
p1 = People() # object
p2 = People() # object
print(p1, p2) # 每个对象的内存地址不同,肯定不是单例模式
基于装饰器的单例模式:
from functools import wraps
def singleton(cls):
# 通过一个字典存储类和对象信息{"Class":"object"}
instances = {}
@wraps(cls)
def wrapper(*args, **kwargs):
# 为了保证单例模式, 判断该类是否已经实例化为对象
# 1. 如果有对象,直接返回存在的对象
# 2. 如果没有则实例化对象, 并存储类和对象到字典中, 最后返回对象
if instances.get(cls):
return instances.get(cls)
object = cls(*args, **kwargs)
instances[cls] = object
return object
return wrapper
@singleton
class People(object):
pass
p1 = People()
p2 = People()
print(p1, p2)
print(p1 is p2) # 判断是否为单例模式(p1和p2内存地址是否相同)
基于new方法实现的单例模式
class People(object):
_instance = None
def __new__(cls, *args, **kwargs):
"""创建对象之前执行的内容"""
if cls._instance is None:
cls._instance = object.__new__(cls)
return cls._instance
def __init__(self):
"""在new方法之后执行, 将属性和对象封装在一起"""
print("正在执行构造方法init......")
p1 = People()
p2 = People()
print(p1, p2)
- new方法是在实例化之前执行的内容
_instance = None
默认没有实例
汇总:
面向对象:
-
三大特性
封装(必须要掌握的):
_new_: 在实例化对象之前执行的, 返回对象。
_init_: 构造方法, 实例化对象时自动执行。 常用于将对象和属性绑定在一起。
self: 实质上是对象。
继承(最多知识点的):
多继承算法: python3中广度优先算法。
私有属性和私有方法
多态(最简单的): -
三大特性的应用
1). 链表的封装(Leetcode第二题)
2). 栈的封装
3). 队列的封装
4). 二叉树的封装与先序遍历 -
高级特性
1). @classmethod和@staticmethod(类方法和静态方法)
2). @property类属性
3). 单例模式: 一个类只能实例化一个对象
基于装饰器
基于new方法