面向对象
2018-11-30 本文已影响7人
GHope
面向对象 - OOP（Object Oriented Programming）
面向对象的四大支柱：
- 抽象：类是抽象的，对象是具体的。定义类的过程就是一个抽象过程，
需要做数据抽象（发现静态特征（属性））和行为抽象（发现动态特征（方法）） - 封装：把数据和操作数据的方法绑定到一起形成对象，通过给对象发消息来解决问题，这是一个隐藏实现细节暴露简单的调用接口的过程
- 继承：从已有的类创建新类的过程，提供继承信息的称为父类（基类/超类），得到继承信息的称为子类（派生类）
- 多态：子类在继承父类过程中可以重写（override）父类已有的方法，
不同的子类可以给出不同的实现版本，那么在调用该方法时就会表现出多态行为
面向对象七原则：
- 单一职责原则 - SRP - 一个类只做该做的事情
- 开闭原则 - 软件实体应该对扩展开发对修改关闭
- 依赖倒转原则（x）
- 里氏替换原则 - 任何时候可以用子类对象替换掉父类对象
- 接口隔离原则（x）
- 合成聚合复用原则 - 优先使用强关联关系而不是继承关系复用代码
- 最少知识原则（迪米特法则）- 不要给没有必然联系的对象发消息
GoF设计模式 - 23种场景 - Python弱化了其中16种：
- 创建型模式
- 结构型模式
- 行为型模式
from abc import ABCMeta, abstractmethod
# 元类 - 描述类的类
# 通过metaclass=ABCMeta可以将一个类声明为抽象类
# 通过abstractmethod装饰器可以将方法装饰为抽象方法
# 抽象类不能实例化（创建对象）它是专门给其他类去继承的
class Employee(object, metaclass=ABCMeta):
"""员工"""
def __init__(self, name):
self.name = name
@abstractmethod
def get_salary(self):
"""获取月薪"""
pass
class Manager(Employee):
"""部门经理"""
# 重写父类的抽象方法（如果没有重写抽象方法那么该类也是抽象类）
# 不同的子类都会重写这个抽象方法所以这个方法就是有多态行为的方法
def get_salary(self):
return 15000
class Programmer(Employee):
"""程序员"""
def __init__(self, name):
super().__init__(name)
self.working_hour = 0
def get_salary(self):
return 200 * self.working_hour
class Salesman(Employee):
"""销售员"""
def __init__(self, name):
super().__init__(name)
self.sales = 0
def get_salary(self):
return 1800 + self.sales * 0.05
def main():
"""主函数"""
emps = [
Manager('曹操'), Programmer('荀彧'),
Programmer('郭嘉'), Salesman('典韦')
]
for emp in emps:
# 通过isinstance函数可以进行类型识别
if isinstance(emp, Programmer):
hour = int(input(f'{emp.name}本月工作时间: '))
emp.working_hour = hour
elif isinstance(emp, Salesman):
sales = float(input(f'{emp.name}本月销售额: '))
emp.sales = sales
print(f'{emp.name}本月工资: {emp.get_salary()}元')
if __name__ == '__main__':
main()
类和类之间的关系
类和类之间的关系：
- is-a关系（继承）
- has-a关系（关联/聚合/合成）
- use-a关系（依赖）
from enum import Enum, unique
import random
# 枚举类型（定义符号常量的最佳选择，符号常量总是优于字面常量）
@unique
class Suite(Enum):
"""花色"""
SPADE, HEART, CLUB, DIAMOND = range(4)
def __lt__(self, other):
return self.value < other.value
class Card(object):
"""牌"""
def __init__(self, suite, face):
"""初始化方法"""
self.suite = suite
self.face = face
def show(self):
"""显示牌面"""
suites = ['♠️', '♥️', '♣️', '♦️']
faces = [
'', 'A', '2', '3', '4', '5', '6',
'7', '8', '9', '10', 'J', 'Q', 'K'
]
return f'{suites[self.suite.value]} {faces[self.face]}'
def __str__(self):
return self.show()
def __repr__(self):
return self.show()
class Poker(object):
"""扑克"""
def __init__(self):
self.index = 0
self.cards = [Card(suite, face)
for suite in Suite
for face in range(1, 14)]
def shuffle(self):
"""洗牌（随机乱序）"""
random.shuffle(self.cards)
self.index = 0
def deal(self):
"""发牌"""
card = self.cards[self.index]
self.index += 1
return card
@property
def has_more(self):
return self.index < len(self.cards)
# Python解释器搜索一个变量会按照LEGB的顺序进行搜索
# Local --> Embedded --> Global --> Built-in
# 在函数中定义的变量正常情况下属于局部作用域
# 但是可以通过nonlocal或global关键字将其放到嵌套或全局作用域
class Player(object):
"""玩家"""
def __init__(self, name):
self.name = name
self.cards = []
def get_one(self, card):
"""摸一张牌"""
self.cards.append(card)
def sort(self, comp=lambda card: card.face):
"""整理手上的牌"""
self.cards.sort(key=comp)
def main():
"""主函数"""
poker = Poker()
poker.shuffle()
players = [
Player('东邪'), Player('西毒'),
Player('南帝'), Player('北丐')
]
for _ in range(13):
for player in players:
player.get_one(poker.deal())
for player in players:
player.sort(lambda card: (card.suite, card.face))
print(player.name, end=': ')
print(player.cards)
if __name__ == '__main__':
main()
多重继承和MRO
UML - Unified Modeling Language - 统一建模语言
标准化的图形符号 - 便于沟通交流 - 一图胜千言
最重要的三种图：用例图 / 类图 / 时序图
多重继承和MRO（方法解析顺序）- Method Resolution Order
Python 2的MRO类似于深度优先搜索
Python 3的MRO类似于广度优先搜索（C3算法）
UML示例
class A(object):
def foo(self):
print('foo() in A')
class B(A):
pass
# def foo(self):
# print('foo() in B')
class C(A):
def foo(self):
print('foo() in C')
class D(B, C):
pass
def main():
print(D.mro())
# print(D.__mro__)
d = D()
d.foo()
if __name__ == '__main__':
main()
