目錄

🏳??🌈開講啦！！！！🏳??🌈蘇州程式大白🏳??🌈

編程語言

與成百種編程語言（Programming Language）相比，編程范式（Programming Paradigm、范式）要少得多，

如圖所示，共有 27 種范式，多數范式之間僅相差一個或幾個概念，

主要的范式

最常用的范式有三個：程序試編程，面向物件編程（OOP），函式式編程（FP），然后我們介紹一下新興的第四種范式也就是面向切面編程（AOP），

程序試編程

程序式編程（Procedural programming）的核心在于模塊化，在實作程序中使用了狀態，依賴了外部變數，導致很容易影響附近的代碼，可讀性較低，后期的維護成本也較高，

程序試編程經歷了發展的兩個階段，非結構化到結構化：

`非機構化編程（Unstructured programming）`：機器語言和匯編語言的編程范式被認為是非結構化編程，沒有封裝函式的概念，代碼中 goto 陳述句滿天飛的狀態，

`結構化編程（Structured programming）`：抽象了機器的行為，屏蔽了部分計算機的硬體細節，代表語言就是我們常用的 C 語言，

有時結構化編程，也稱作程序式編程，或面向程序編程，

def get_shannon_info(output):
    """獲取shannon型別flash卡資訊
    """

    def check_health():
        time_left = float(sub_info["life_left"])
        if time_left < DISK_ALARM_LIFETIME:
            message = "time left is less than {}%".format(DISK_ALARM_LIFETIME)
            return message
        temperature = float(sub_info["temperature"].split()[0])
        if temperature > DISK_ALARM_TEMPERATURE:
            message = "temperature is over than {} C".format(DISK_ALARM_TEMPERATURE)
            return message
        return "healthy"

    result = {}
    all_info = _get_shannon_info(output)
    for info in all_info:
        sub_info = {}
        sub_info["available_capacity"] = info.get("disk_capacity", "")
        sub_info["device_name"] = info.get("block_device_node", "")
        sub_info["firmware_version"] = info.get("firmware_version", "")
        sub_info["interface"] = "PCIe"
        sub_info["life_left"] = str(info.get("estimated_life_left", "").replace("%", ""))
        sub_info["pcie_id"] = info.get("pci_deviceid", "")
        sub_info["pcie_length"] = ""
        sub_info["pcie_type"] = ""
        sub_info["physical_read"] = info.get("host_read_data", "")
        sub_info["physical_write"] = info.get("total_write_data", "")
        sub_info["serial_number"] = info.get("serial_number")
        sub_info["temperature"] = info.get("controller_temperature")
        sub_info["type"] = info["type"]
        sub_info["error_msg"] = check_health()
        sub_info["status"] = "ok" if sub_info["error_msg"] == "healthy" else "error"
        if sub_info["serial_number"]:
            result[sub_info["serial_number"]] = sub_info
        else:
            result[sub_info["device_name"]] = sub_info
    return result

面向物件編程

面向物件編程（Object-oriented programming）的核心在于抽象，提供清晰的物件邊界，結合封裝、集成、多型特性，降低了代碼的耦合度，提升了系統的可維護性，C++ 和 之后的 Java 成為主流，

人們將領域問題又開始映射成物體及關系（程式 = 物體 + 關系），而不再是資料結構和演算法（程序）了，這就是面向物件編程，核心特點是封裝、繼承和多型，

class IFlash(six.with_metaclass(abc.ABCMeta)):
    def __init__(self):
        pass

    @abc.abstractmethod
    def collect(self):
        """收集flash卡物理資訊
        """
        pass


class FlashShannon(IFlash):
    """寶存的Flash卡
    """

    def __init__(self, txt_path, command, printer):
        super(FlashShannon, self).__init__()
        self.txt_path = txt_path

        self.command = command
        self.printer = printer

    def collect(self):
        result = {}
        for info in self._get_shannon_info():
            life_left = str(info.get("estimated_life_left", "")).replace("%", "")
            temperature = info.get("controller_temperature", "")
            error_msg = self._get_health_message(life_left, temperature)
            sub_info = {
                "available_capacity": info.get("disk_capacity", ""),
                "device_name": info.get("block_device_node", ""),
                "firmware_version": info.get("firmware_version", ""),
                "interface": "PCIe",
                "life_left": life_left,
                "pcie_id": info.get("pci_deviceid", ""),
                "pcie_length": "",
                "pcie_type": "",
                "physical_read": info.get("host_read_data", ""),
                "physical_write": info.get("total_write_data", ""),
                "serial_number": info.get("serial_number", ""),
                "temperature": temperature,
                "type": info["type"],
                "error_msg": error_msg,
                "status": "ok" if error_msg == "healthy" else "error"
            }
            if sub_info["serial_number"]:
                result[sub_info["serial_number"]] = sub_info
            else:
                result[sub_info["device_name"]] = sub_info
        return result


class FlashFio(IFlash):
    """fio的Flash卡
    """

    def __init__(self, txt_path):
        super(FlashFio, self).__init__()
        self.txt_path = txt_path

    def collect(self):
        disk_info = {}
        adapter_info = self._get_adapter_info()
        for info in adapter_info:
            serial_number = info["fio_serial_number"]
            for io in info["iomemory"]:
                data = self._combining_io_memory(io)
                data["serial_number"] = serial_number
                disk_info[serial_number] = data
        return disk_info

函式式編程

函式式編程（Functional Programming）的核心在于 “避免副作用”，不改變也不依賴當前函式外的資料，結合不可變資料、函式是第一等公民等特性，使函式帶有自描述性，可讀性較高，

首先，函式式編程的主要理論基礎是 Lambda 演算，它是圖靈完備的；其次，函式式編程是抽象代數思維，更加接近現代自然科學，使用一種形式化的方式來解釋世界，通過公式來推導世界，極度抽象（比如 F=ma），在這條路上，很多人都是偏學術風格的，他們關注解決方案是否優雅，如何一層層構建抽象，他們也探索更多的可能，垃圾回識訓制就是從這里率先出來的，

@pytest.mark.parametrize("line, result", [
("Found Shannon PCIE", False),
("Found Shannon PCIE Flash car", False),
("Found Shannon PCIE Flash card a", True),
("Found Shannon PCIE Flash card", True),
("Found Shannon PCIE Flash card.", True),
])
def test_is_shannon_flash_device(line, result):
    assert functional.is_shannon_flash_device(line) == result


@pytest.mark.parametrize("line, result", [
("a=1", True),
("b=2", True),
("c=2333", True),
("d x=abcde", True),
("Found Shannon PCIE=1", True),
("abcdedfew=", False),
("Found Shannon PCIE", False),
(" =Found Shannon PCIE", False),
("=Found Shannon PCIE", False),
("Found Shannon PCIE=", False),
("Found Shannon PCIE= ", False),
])
def test_is_effective_value(line, result):
    assert functional.is_effective_value(line) == result


@pytest.mark.parametrize("line, result", [
("a=1", {"a": "1"}),
("b=2", {"b": "2"}),
("a=a", {"a": "a"}),
("abc=a", {"abc": "a"}),
("abc=abcde", {"abc": "abcde"}),
])
def test_gets_the_index_name_and_value(line, result):
    assert functional.gets_the_index_name_and_value(line) == result


@pytest.mark.parametrize("output, filter_func, result", [
("abcd\nbcd\nabcd\nbcd\naa\naa", lambda x: "a" in x, ["abcd\nbcd", "abcd\nbcd", "aa", "aa"]),
(open(os.path.join(project_path, "fixtures", "shannon-status.txt")).read(), functional.is_shannon_flash_device, [
    open(os.path.join(project_path, "fixtures", "shannon-sctb.txt")).read(),
    open(os.path.join(project_path, "fixtures", "shannon-scta.txt")).read()
])
])
def test_checks_string_split_by_function(output, filter_func, result):
    assert functional.checks_string_split_by_function(output, filter_func) == result

面向切面編程

面向切面編程（Aspect Oriented Programming、AOP）為開發人員提供了一種描寫敘述橫切關注點的機制，并可以自己主動將橫切關注點織入到面向物件的軟體系統中，從而實作了橫切關注點的模塊化，

AOP 可以將那些與業務無關，卻為業務模塊所共同呼叫的邏輯或責任，比如事務處理、日志管理、權限控制等，封裝起來，便于降低系統的反復代碼，降低模塊間的耦合度，并有利于未來的可操作性和可維護性，

python 可以使用裝飾器實作 AOP，

主要三種范式的對比

領域驅動設計

不難看出，編程語言的發展就是一個逐步遠離計算機硬體，向著待解決的領域問題靠近的程序，所以，編程語言后續的發展方向就是探索怎么更好的解決領域問題，也就是領域驅動設計（Domain-driven Design、DDD），

DDD 的精髓是對邊界的劃分和控制，共有四重邊界：

1、第一重邊界是在問題空間分離子域，包括核心域，支撐域和通用域，

2、第二重邊界是在解決方案空間拆分 BC（限界背景關系，Bounded Context），BC 之間的協作關系通過 Context Mapping（背景關系映射） 來表達，

3、第三重邊界是在 BC 內部分離業務復雜度和技術復雜度，形成分層架構，包括用戶界面層，應用層，領域層和基礎設施層，

4、第四重邊界是在領域層引入聚合這一最小的設計單元，它從完整性與一致性對領域模型進行了有效的隔離，聚合內部包括物體、值物件、領域服務、工廠和倉儲等設計元素，

設計原則與模式

設計原則很多，程式員最常使用的是 SOLID 原則，它是一套比較成體系的設計原則，它不僅可以指導我們設計模塊（類），還可以被當作一把尺子，來衡量我們設計的有效性，

SOLID 原則是五個設計原則首字母的縮寫，它們分別是：

單一職責原則（Single responsibility principle，SRP）：一個類應該有且僅有一個變化的原因，

開放封閉原則（Open–closed principle，OCP）：軟體物體（類、模塊、函式）應該對擴展開放，對修改封閉，

里氏替換原則（Liskov substitution principle，LSP）：子型別（subtype）必須能夠替換其父型別（base type），

介面隔離原則（Interface segregation principle，ISP）：不應強迫使用者依賴于它們不用的方法，

依賴倒置原則（Dependency inversion principle，DIP）：高層模塊不應依賴于低層模塊，二者應依賴于抽象；抽象不應依賴于細節，細節應依賴于抽象，

前面我們提到，對于面向物件來說，核心是多型的設計，我們看看 SOLID 原則如何指導多型設計：

單一職責原則：通過介面分離變與不變，隔離變化，

開放封閉原則：多型的目標是系統對于變化的擴展而非修改，

里氏替換原則：介面設計要達到細節隱藏的圓滿效果，

介面隔離原則：面向不同客戶的介面要分離開，

依賴倒置原則：介面的設計和規定者應該是介面的使用方法，

除過設計原則，我們還要掌握常用的設計模式，設計模式是針對一些普遍存在的問題給出的特定解決方案，使面向物件的設計更加靈活和優雅，從而復用性更好，學習設計模式不僅僅要學習代碼怎么寫，更重要的是要了解模式的應用場景，不論那種設計模式，其背后都隱藏著一些 “永恒的真理”，這個真理就是設計原則，的確，還有什么比原則更重要呢？就像人的世界觀和人生觀一樣，那才是支配你一切行為的根本，可以說，設計原則是設計模式的靈魂，

守破離是武術中一種漸進的學習方法：

第一步 —— 守，遵守規則直到充分理解規則并將其視為習慣性的事，

第二步 —— 破，對規則進行反思，尋找規則的例外并 “打破” 規則，

第三步 —— 離，在精通規則之后就會基本脫離規則，抓住其精髓和深層能量，

設計模式的學習也是一個守破離的程序：

第一步 —— 守，在設計和應用中模仿既有設計模式，在模仿中要學會思考，

第二步 —— 破，熟練使用基本設計模式后，創造新的設計模式，

第三步 —— 離，忘記所有設計模式，在設計中潛移默化的使用，

參考文章：
淺談編程范式

聊聊編程范式

AOP----面向切面編程 Python

🌟作者相關的文章、資源分享🌟

🌟讓天下沒有學不會的技術🌟
學習C#不再是難問題
🌳《C#入門到高級教程》🌳
有關C#實戰專案
👉C#RS232C通訊原始碼👈
👉C#委托資料傳輸👈
👉C# Modbus TCP 源代碼👈
👉C# 倉庫管理系統原始碼👈
👉C# 歐姆龍通訊Demo👈
👉C#+WPF+SQL目前在某市上線的車管所攝像系統👈
👉2021C#與Halcon視覺通用的框架👈
👉2021年視覺專案中利用C#完成三菱PLC與上位機的通訊👈
👉VP聯合開源深度學習編程(WPF)👈
?有關C#專案歡迎各位查看個人主頁?

🌟機器視覺、深度學習🌟
學習機器視覺、深度學習不再是難問題
🌌《Halcon入門到精通》🌌
🌌《深度學習資料與教程》🌌
有關機器視覺、深度學習實戰
👉2021年C#+HALCON視覺軟體👈
👉2021年C#+HALCON實作模板匹配👈
👉C#集成Halcon的深度學習軟體👈
👉C#集成Halcon的深度學習軟體，帶[MNIST例子]資料集👈
👉C#支持等比例縮放拖動的halcon WPF開源表單控制元件👈
👉2021年Labview聯合HALCON👈
👉2021年Labview聯合Visionpro👈
👉基于Halcon及VS的動車組制動閘片厚度自動識別模塊👈
?有關機器視覺、深度學習實戰歡迎各位查看個人主頁?

🌟Java、資料庫教程與專案🌟
學習Java、資料庫教程不再是難問題
🍏《JAVA入門到高級教程》🍏
🍏《資料庫入門到高級教程》🍏
有關Java、資料庫專案實戰
👉Java經典懷舊小霸王網頁游戲機原始碼增強版👈
👉js+css類似網頁版網易音樂原始碼👈
👉Java物業管理系統+小程式原始碼👈
👉JavaWeb家居電子商城👈
👉JAVA酒店客房預定管理系統的設計與實作SQLserver👈
👉JAVA圖書管理系統的研究與開發MYSQL👈
?有關Java、資料庫教程與專案實戰歡迎各位查看個人主頁?

🌟分享Python知識講解、分享🌟
學習Python不再是難問題
🥝《Python知識、專案專欄》🥝
🥝《Python 檢測抖音關注賬號是否封號程》🥝
🥝《手把手教你Python+Qt5安裝與使用》🥝
🥝《用一萬字給小白全面講解python編程基礎問答》🥝
🥝《Python 繪制Android CPU和記憶體增長曲線》🥝
🥝《??蘇州程式大白用萬字決議Python網路編程與Web編程??《??記得收藏??》》🥝
有關Python專案實戰
👉Python基于Django圖書管理系統👈
👉Python管理系統👈
👉2021年9個常用的python爬蟲原始碼👈
👉python二維碼生成器👈
?有關Python教程與專案實戰歡迎各位查看個人主頁?

🌟分享各大公司面試題、面試流程🌟
面試成功不是難事
🍏《2021年金九銀十最新的VUE面試題??《??記得收藏??》》🍏
🍏《只要你認真看完一萬字??Linux作業系統基礎知識??分分鐘鐘都吊打面試官《??記得收藏??》》🍏
🍏《??用一萬字給小白全面講解python編程基礎問答??《😀記得收藏不然看著看著就不見了😀》》🍏
?有關各大公司面試題、面試流程歡迎各位查看個人主頁?