二階段day14-vim編輯器實操（python3）

1、買雞問題

#!/usr/bin/python3
"""
百錢百雞: 公雞5元一隻，母雞3元一隻，小雞1元三隻
用100元買100只雞，問公雞、母雞、小雞各多少隻
"""


def main():
    """主函式(程式入口)"""
    for cock in range(0, 21):
        for hen in range(0, 34):
            chicken = 100 - cock - hen
            if chicken % 3 == 0 and 5 * cock + 3 * hen + chicken // 3 == 100:
                print(f'公雞: {cock}, 母雞: {hen}, 小雞: {chicken}')

if __name__ == '__main__':
    main()

2、約瑟夫環

#!/usr/bin/python3
"""
約瑟夫環問題
30人坐船，15人教徒，15人非教徒，現需扔15人下水，問如何坐一圈來保證扔下去的全是非教徒
"""

def main():
    """主函式"""
    persons = [True] * 30
    index, number, counter = 0, 0, 0
    while counter < 15:
        if persons[index]:
            number += 1
            if number == 9:
                persons[index] = False
                counter += 1
                number = 0
        index += 1
        index %= len(persons)
    for person in persons:
        print('基' if person else '非', end='')
    print()
    

if __name__ == '__main__':
    main()

3、撲克遊戲

#!/usr/bin/python3
"""
撲克遊戲
類和類之間（物件之間）的關係:
1. is-a關係 - 繼承
2. has-a關係 - 關聯/聚合/合成
3. use-a關係 - 依賴
物件導向七個設計原則：
1. 單一職責原則 - 一個類只做該做的事情不做不該做事情
2. 開閉原則
3. 依賴倒轉原則
4. 里氏替換原則
5. 介面隔離原則
6. 合成聚合複用原則 - 優先考慮強關聯關係而不是繼承關係來複用程式碼
7. 最少知識原則（迪米特法則）
GoF設計模式：23種經典場景 - Python中弱化了很大一部分
"""
from enum import Enum
from enum import unique

import random


# 經驗: 符號常量優於字面常量 列舉型別是定義符號常量的最佳選擇
@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 __lt__(self, other):
        if self.suite == other.suite:
            return self.face < other.face
        return self.suite.value < other.suite.value
    """

    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)        

    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 x: (x.suite.value, x.face)):
        """整理手上的牌"""
        self.cards.sort(key=key)


def main():
    if True:
        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)
            print(player.name, end=': ')
            print(player.cards)


if __name__ == '__main__':
    main()

4、工資系統

#!/usr/bin/python3
"""
物件導向的四大支柱: 抽象、封裝、繼承、多型
抽象 - 定義類的過程就是提取共性的抽象過程
資料抽象 - 找到物件的靜態特徵 - 屬性 - 找名詞
行為抽象 - 找到物件的動態特徵 - 方法 - 找動詞
封裝 - 將資料和運算元據的方法從邏輯上組成一個整體 - 物件
隱藏實現細節 暴露簡單的呼叫介面
繼承 - 從已有的類建立新類的過程
提供繼承資訊的稱之為父類 得到繼承資訊的稱之為子類
多型 - 呼叫相同的方法做了不同的事情 - 同樣的方法在執行時表現出不同行為
子類重寫父類方法 不同的子類給出不同的實現版本
"""
from abc import ABCMeta, abstractmethod


class Employee(object, metaclass=ABCMeta):
    """員工（抽象類）"""

    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name or '無名氏'

    @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()}元')
        print('%s本月工資為%d元' %(emp.name,emp.get_salary()))

if __name__ == '__main__':
    main()