面向对象编程 （三大特征：封装、继承、多态）
封装
1. 什么是封装
顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。 所以，在使用面向对象的封装特性时，需要：
- 将内容封装到某处
- 从某处调用被封装的内容
- 通过对象直接调用被封装的内容： 对象.属性名
- 通过self间接调用被封装的内容： self.属性名
- 通过self间接调用被封装的内容: self.方法名()
2. 注 ：
1. __init__ :构造方法，实例化对象时自动执行的方法 (构造方法__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调 用构造方法。自动执行构造方法里面的内容。)
2. self是什么? self实质上是实例化的对象
3. 类方法中, python解释器会自动把对象作为参数传给self3. 示例
示例1：封装特性
# 类(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()执行结果：
正在执行__init__构造方法
self: <__main__.Cat object at 0x0000020D9FC79FD0>
粉条
美短虎斑
cat 粉条 like eating fish.....
示例2：巩固封装特性
"""
创建一个类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()执行结果
小明,18岁,男,去西安赛格购物广场购物
小王,22岁,男,去西安赛格购物广场购物
小红,10岁,女,在西部开源学习示例3：链表的封装
"""
参考链接 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)
执行结果
7,0,8,示例4：栈的封装
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执行结果
入栈元素为1
入栈元素为2
入栈元素为3
3
出栈元素为3
False
2示例5：二叉树的封装
"""
二叉树:
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)
执行结果
1
2
4
8
9
5
10
3
6
7示例6：队列的封装
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执行结果
入队元素为: 1
入队元素为: 2
入队元素为: 3
False
出队元素: 1
2
3继承
1. 什么是继承
继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class 继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、 Superclass)
2. 继承（只有一层继承关系）
1、子类继承父类的属性和方法
2、继承实现方法（定义子类时实现继承）：class Subclass (SuperClass) :
示例7：继承的实现
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() # 报错, 子类里没有，父类也没有的方法
执行结果
粉条博士
8
粉条博士正在学习3. 子类对父类方法重写（用super 函数实现）：
super() 函数是用于调用父类(超类)的一个方法
super(Subclass, self).method() #用子类对象调用父类已被覆盖的方法示例8：重写父类方法
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()
执行结果
**********************正在选课中***********************
课程表
1. 高等数学
2. 线性代数
3. 概率论
**********************正在选课中***********************4. 多继承 （有多层继承关系）
1、一个子类可以继承多个父类。
2、多继承实现（定义子类时实现继承）：class Subclass (SuperClass1, SuperClass2, SuperClass3) :
注：需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
3、多继承涉及新式类和经典类问题（主要区别是搜索的算法问题）：
新式类（ 广度优先算法 ）：在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式 类” ，都会获得所有“新式类”的特性
经典类（ 深度优先算法 ）：不由任意内置类型派生出的类， 则称之为“经典类”。
广度优先算法和深度优先算法的区别：
示例9：多继承
"""
新式类: 广度优先算法
经典类： 深度优先算法(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()
执行结果：
D5. 私有属性与私有方法
类的私有属性（属性名以双下划线开头）：
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
类的私有方法（方法名以双下划线开头）：
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。
工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
示例10：私有属性和私有方法
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)
执行结果：
报错原因: 子类无法继承父类的私有属性和私有方法。
Traceback (most recent call last):
File "C:\Users\Administrator\Desktop\python\day06\08_私有属性和私有方法.py", line 30, in <module>
score = s1.get_score()
File "C:\Users\Administrator\Desktop\python\day06\08_私有属性和私有方法.py", line 25, in get_score
self.__modify_score()
AttributeError: 'MathStudent' object has no attribute '_MathStudent__modify_score'多态
1. 什么是多态
1、多态（Polymorphism）按字面的意思就是“多种状态” 。在面向对象语言中，接口 的多种不同的实现方式即为多态。通俗来说： 同一操作作用于不同的对象，可以有不 同的解释，产生不同的执行结果。
2、多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接 不重写（即使用父类的），也可以重写一个特有的。这就是多态的意思。调用方只管调用，不管 细节，而当我们新增一种的子类时，只要确保新方法编写正确，而不用管原来的代码。
2. “开闭”原则：
这就是著 名的“开闭”原则：
- 对扩展开放（Open for extension）：允许子类重写方法函数
- 对修改封闭（Closed for modification）：不重写，直接继承父类方法函数