Day014 - Linux-Vim(2)（2018-11-17）

find /etc -name "*.conf" -> 在etc目录下面查找conf文件
grep -> 查找字符串

面向对象四大支柱：抽象、封装、继承、多态

抽象 - 定义类的过程就是提取共性的抽象过程
数据抽象 - 找到对象的静态特征 - 属性 - 找名词
行为抽象 - 找到对象的动态特征 - 方法 - 找动词

封装 - 将数据和操作数据的方法从逻辑上组成一个整体 - 对象
隐藏实现细节 暴露简单的调用接口

继承 - 从已有的类创建新类的过程
提供继承信息的称之为父类，得到继承信息的称之为子类

多态 - 调用相同的方法，做了不同的事情
同样的方法在运行时表现出不同的行为
子类重写父类方法，不同的子类给出不同的实现版本

抽象类：在抽象类中声明的抽象方法必须要在子类中实现，抽象方法不能被继承

 class Employee(object, metaclass=ABCMeta):
 
    @abstractmethod
    def ……

查找替换：
/ 进入末行模式，输入查找内容 小写n往下搜索，大写N往上搜索
:1,$ 从第一行到最后一行
:1,$s/self/shit 从第一行到最后一行,找到self替换成shit (s:substitute)
:1,$s/self/shit/c 从第一行到最后一行,找到self替换成shit,并需要进行确认
:1,$s/self/shit/ci 从第一行到最后一行,找到self替换成shit,并需要进行确认，同时忽略大小写（i:ignore case)

名词：扑克 玩家 牌
动词：洗牌 发牌 摸牌

类和类之间（对象之间）的关系：

1. is-a关系 - 继承
2. has-a关系 - 关联（学生有笔记本电脑）/聚合/合成 （（强关联）小汽车有引擎：聚合或者合成）
3. use-a关系 - 依赖

面向对象七个设计原则：

1.单一职责原则 - 一个类只做该做的事情，不做不该做的事情
2.开闭原则
3.依赖倒转原则
4.里氏替换原则
5.接口隔离原则
6.合成聚合复用原则 - 优先考虑强关联关系而不是继承关系来复用代码
7.最少知识原则（迪米特法则）

设计模式：
GoF设计模式（23种经典场景，有17种在python中被弱化了（因为是动态弱类型语言））

！经验： 符号常量优于字面常量，枚举类型是定义符号常量的最佳选择
SPADE.value可以取到常量的值，Suite是可以迭代的类型

class Suite(Enum):
     SPADE = 0
     HEART = 1
     CLUB = 2
     DIAMOND = 3

__repr__:
对象作为列表的元素时，打印自动调用__repr__

def func1(a, *, key='')
*前面的参数称为位置参数（传参时不用指定参数名，按位置对号入座即可）
*后面的参数称为命名关键字参数（传参时必须给出参数名和参数值）

工资结算系统：

#!/usr/bin/python3
from abc import 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):
        self.working_hour = 0
        super().__init__(name)

    def get_salary(self):
        return 200 * self.working_hour


class Salesman(Employee):
    """销售员"""

    def __init__(self, name):
        self.sales = 0
        super().__init__(name)

    def get_salary(self):
        return 1800 + self.sales * 0.05


def main():
    emps = [
        Manager('曹操'), Programmer('荀彧'),
        Programmer('郭嘉'),  Salesman('张辽')
    ]
    for emp in emps:
        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()

扑克游戏：

#!/usr/bin/python3
from enum import Enum, unique
import random


# 经验： 符号常量优于字面常量，枚举类型是定义符号常量的最佳选择
# SPADE.value可以取到常量的值，Suite是可以迭代的类型
@unique
class Suite(Enum):
    """花色的枚举"""
    
    SPADE = 0
    HEART = 1
    CLUB = 2
    DIAMOND = 3


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

    """
    def __gt__(self, other):
        if self.suite == other.suite:
            return self.face > other.face
        return self.suite.value > other.suite.value
    """

class Poker:
    
    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) 

    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 Player(object):
    """玩家(与牌既有关联关系，又有依赖关系)"""

    def __init__(self, name):
        self.name = name
        self.cards = []

    def get_one(self, card):
        """摸一张牌"""
        self.cards.append(card)

    def sort_cards(self, key=lambda card: (card.suite.value, card.face)):
        """玩家整理手上的牌"""
        self.cards.sort(key=key)


def main():
    poker = Poker()
    poker.shuffle()
    print(poker.cards)
    players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]
    for _ in range(13):
        for player in players:
            player.get_one(poker.deal())
    for player in players:
        player.sort_cards(key=lambda card: (card.face, card.suite.value))
        print(player.name, end=': ')
        print(player.cards)


if __name__ == '__main__':
    main()