面向对象

面向对象 - OOP(Object Oriented Programming)

• 面向对象的四大支柱:

  1. 抽象: 类是抽象的, 对象是具体的. 定义类的过程就是一个抽象过程, 需要做数据抽象(发现静态特征(属性)) 和行为抽象(发现动态特征(方法))
  2. 封装: 把数据和操作数据的方法绑定到一起形成对象, 通过给对象发消息来解决问题, 这是一个隐藏实现细节暴露简单的调用接口的过程
  3. 继承: 从已有的类创建新类的过程, 提供继承信息的称为父类(基类/超类), 得到继承信息的成为子类(派生类)
  4. 多态: 字类再继承父类过程中可以重写父类(override)已有的方法, 不同的字类可以给出不同的实现版本, 调用相同的方法时会表现出多态的行为

• 面向对象七原则:

  1. 单一职责原则 - SRP - 一个类只做该做的事情
  2. 开闭原则 - 软件实体应该对扩展开发对修改关闭
  3. 依赖倒转原则(x)
  4. 里氏替换原则 - 任何时候可以用字类对象替换掉父类对象
  5. 接口隔离原则(x)
  6. 合成聚合复用原则 - 优先使用强关联关系而不是继承关系复用代码
  7. 最少知识原则(迪米特法则) - 不要给没有必然联系的对象发消息

• 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()