面向对象 - 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
# class Gender(Enum):
# MALE = 1
# FEMALE = 0
# UNKNOWN = 2
# 枚举类型 - 定义符号常量的最佳选择, 符号常量总是优于字面常量
@unique
class Suite(Enum):
"""花色"""
SPADE = 0
HEART = 1
CLUB = 2
DIAMOND = 3
class Card(object):
"""牌"""
def __init__(self, suite, face):
"""初始化方法
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)
class Players(object):
"""玩家类"""
def __init__(self, name):
# Python解释器搜索一个变量会按照LEGB的顺序进行搜索
# Local -> Embedded -> Global -> Built-in
# 在函数中定义的变量正常请款下属于局部作用域
# 但是可以通过nonlocal或者global关键字将其放到嵌套或全局作用域
self.name = name
self.cards = []
def get_one(self, card):
"""摸一张牌"""
self.cards.append(card)
def sort_card(self, comp=lambda card: (card.suite.value, card.face)):
"""整理手上的牌"""
self.cards.sort(key=comp)
def main():
poker = Poker()
poker.shuffle()
players = [
Players('东邪'), Players('西毒'), Players('南帝'),
Players('北丐')
]
for _ in range(13):
for player in players:
player.get_one(poker.deal())
for player in players:
player.sort_card()
print(player.name, player.cards)
if __name__ == '__main__':
main()
类的继承
"""
UML - Unified Modeling Language - 统一建模语言
标准化的图形符号 - 便于沟通交流 - 一图胜千言
最重要的三种图：用例图 / 类图 / 时序图
多重继承和MRO（方法解析顺序）- Method Resolution Order
Python 2的MRO类似于深度优先搜索
Python 3的MRO类似于广度优先搜索（C3算法）
"""
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()
