1. 滾雪球學Python第四季開啟，一需三吃，Python 函式式編程初識，面向程序，面向物件，函式式

滾雪球學 Python 第四輪，這一番我們要學習點有難度的了，因此，橡皮擦將降低閱讀與理解難度，盡量采用大白話為你鋪墊，

寫在前面

這一輪的學習，非常偏理論，因為涉及的一些概念也是借鑒的其它編程語言的風格，而且實際落地中存在部分爭議

不過多學一點，總是沒有壞處的，

滾雪球學 Python 第四輪，主要學習函式式編程

本系列文章每篇 3000 字左右（包含代碼），所以放心享用，不會增大每日學習強度滴

滾雪球歷史系列，已完成 3 個專欄，更新中 1 個專欄，即第三輪學習更新中，目前到 21 篇~，由于第三輪是專案實踐，學 Django 去，所以第四輪概念類同步開啟，

• 滾雪球學 Python（完結）
• 滾雪球學 Python 第二輪（完結）
• 滾雪球學 Python 第三輪（更新中）
• 滾雪球學 Python 番外篇（完結）

Python 函式式編程

Python 不是純粹的函式式語言，但你可以使用 Python 進行函式式編程

典型的聽君一席話，如聽一席話，說白了就是 Python 具備函式式編程的特性，

so，可以借用函式式語言的設計模式和編程技術，把代碼寫成函式式編程的樣子

一般此時我會吹噓一下，函式式代碼比較簡潔和優雅~

好了，已經吹噓完了，

以上內容都屬于講道理的范圍，那在 Python 中有哪些適合函式式編程的技能點

又有哪些不適的點呢？

下述 2 點先有個印象就行

• 優點：生成器運算式，這個后面咱會反復提及，具備很多高階函式，例如 reduce，map，filter 三巨頭，
• 缺點：沒有無限遞回等~

如果你去百度 “什么是函式式編程”，很多地方會給出答案

函式式編程：允許把函式本身作為引數傳入另一個函式，還允許回傳一個函式，

有道理！

其實函式式編程就是在函式中定義運算式和實作運算式的求職，說白了就是用函式落地你的代碼，

看起來好像是廢話，它還有一個補充的說明，在函式式編程中要避免狀態變化和使用可變物件，

其中避免狀態變化 重點要關注賦值陳述句以及它如何改變狀態，因此你在函式式編程中，不會看到 global，nolocal 等內容，

同一案例的不同寫法，展示函式式編程

概念與原理都是比較抽象的，咱還是少說概念，這個留到未來你自己總結就好，直接展示原始碼差異，

計算 1~100 內，計算 5 與 7 的倍數之和

面向程序的寫法

count = 0
for num in range(1, 101):
    if num % 5 == 0 or num % 7 == 0:
        count += num

print(count)

在面向程序的寫法中，邏輯都是從上向下進行運行的，例如 num 從 1 數到 100，如果對 5 或者對 7 取余等于 0，那表示可以整除，然后將 count 與對應的 num 相加，得到最后的余數，

這種思路是純面向程序的寫法，一般我們學習編程時，首先學會的就是該類寫法，

面向物件的寫法

該類寫法有兩種，一種是使用 Python 內置的串列實作，一種是自己宣告一個類來實作，

第一種寫法：

count = list()
for num in range(1, 101):
    if num % 5 == 0 or num % 7 == 0:
        count.append(num)

print(sum(count))

在上述寫法中，變數 count 宣告一個 list，即串列物件，但是整理看起來還是有些程序式編程語言的影子，

例如最后的 sum(count) 的使用就有些奇怪，看不出來面向物件的影子，

接下來，咱們創建一個自定義的類，進行邏輯實作，

class My_List_Sum(list):
    def sum(self):
        count = 0
        for n in self:
            count += n

        return count


count = My_List_Sum()
for num in range(1, 101):
    if num % 5 == 0 or num % 7 == 0:
        count.append(num)

print(count.sum())

上述代碼，我們自行實作了一個 My_List_Sum 類，讓它繼承自 list，此時你應該明白，list 就是一個類名，然后在類的內部實作了 sum 方法，再呼叫該物件的 sum 方法，完美的應用了面向物件的寫法，

接下來進入正題，函式式編程的落地實作

在正式撰寫前，需要回憶一些基礎知識，例如 lambda 運算式以及串列相加，

判斷一個數字是 5 或者 7 的倍數， lambda 寫法如下：

multiple = lambda x: x % 5 == 0 or x % 7 == 0
a = multiple(3) # False
b = multiple(5) # True
c = multiple(7) # False
print(a, b, c)

串列相加代碼如下：

print([1]+[2]) # [1,2]

有了上述內容，可以撰寫一個遞回函式，實作對應的邏輯，代碼的說明已經添加到注釋中，

def tool(n: int, end: int, filter_func) -> list:
    """回傳一個篩選之后的串列
    :param n: 起始值
    :param end: 終止值
    :param filter_func: 判斷運算式
    """
    # 如果到達上限，直接回傳空串列
    if n == end: return []
    # 如果滿足過濾條件，回傳該值與下一個值組成的串列
    if filter_func(n):
        return [n] + tool(n + 1, end, filter_func)
    else:
        # 不滿足過濾條件，直接回傳下一個值
        return tool(n + 1, end, filter_func)


# 測驗代碼
ret = tool(1, 101, lambda x: x % 5 == 0 or x % 7 == 0)
print(ret)
print(sum(ret))

上述代碼即為求和的函式式實作，其中部分邏輯如下：

1. 給定初始值與上限值，當迭代的值等于上限值時，回傳空串列，即運行結束；
2. 傳入一個判斷條件，本案例中為一個 lambda 運算式，用于判斷 5 和 7 的倍數；
3. 當滿足條件時，進行的是相加+迭代作業，當不滿足條件時，直接進入下一次迭代，

當然還有一種函式式編程的寫法，代碼如下：

print(sum(n for n in range(1, 101) if n % 5 == 0 or n % 7 == 0))

這里用到的生成器后文會進行說明，

Python 函式式編程的特點

在 Python 中，函式即物件，例如宣告一個函式之后，你可以呼叫其屬性，

下述代碼展示的即為函式物件的屬性，其余內容可以自行再做測驗，

def my_func(var1, var2, **kw):
    return var1 + var2


print(type(my_func))  # <class 'function'>
print(my_func.__code__)
print(my_func.__dict__)
print(my_func.__code__.co_code)
print(my_func.__code__.co_filename)
print(my_func.__code__.co_argcount)

函式式編程之所以高效，其中一個很重要的原因就是延遲計算，也叫做惰性求值，這些在后面都將逐步展開，現在依舊是接收一下印象概念，

正是因為函式即物件，所有才有本文開篇那段對函式式編程的定義，

函式可以使用其它函式作為引數，或者回傳另一個函式，所以在實際編碼程序中，我們將會把函式轉換成其它代碼中的 “物件”，從而實作函式式編程，

接下來咱們要接觸一下 Python 中的純函式概念以及應用，

純函式

純函式是一個概念，也就是讓函式不會對函式外作用域產生影響，即作用域為本地，

說簡單點，就是在函式內部避免賦值操作，當然類似 global 等關鍵字也避免使用，

針對此，lambda 運算式就是純函式，

首先查看一個純函式的例子：

def my_func(num: int) -> int:
    return num * 100

上述代碼中函式的回傳值僅與 num 有關，滿足下面兩個條件：

1. 沒有改變全域變數；
2. 沒有更新可變資料結構，例如串列，字典，

接觸完畢純函式概念之后，下面了解一下函式作為物件的落地應用，

在 Python 中宣告一個類，默認會攜帶部分內置的方法，例如：

from typing import Callable


# 宣告一個類，該類無意義，僅測驗使用
class Ext:
    # 傳入的函式，可攜帶1~2個引數
    def __init__(self, test_demo: Callable[[int], int]) -> None:
        self.func = test_demo

    # 回傳結果擴大2倍
    def __call__(self, arg: int) -> int:
        return self.func(arg) * 2


def one_func(var):
    return var + 1


def two_func(var):
    return var * 3


def three_func(var):
    return var


a = Ext(one_func)
print(a(3))  # 8

b = Ext(two_func)
print(b(3))  # 18

c = Ext(three_func)
print(c(3))  # 6

上述代碼使用了一個新的模塊 typing，該模塊是 Python 3.5 之后新增的模塊，主要為 Python 提供靜態型別的檢查 ，

本案例中匯入的是回呼函式 Callable，格式如下：

Callable[[Arg1Type, Arg2Type],ReturnType]

其中內部中括號 Arg1Type 是引數型別，ReturnType 為回傳值型別，

上述三個函式的簽名都與 Callable 定義的一致，所以都可以作為 test_demo 引數的值去傳遞，

寫在后面

滾雪球學Python第四輪，非常理論的一個系列，跟上大部隊的節奏，走起來，有任何問題，都可以在評論區留言，一般1小時之內都能解決，

今天是持續寫作的第 213 / 365 天，
可以關注，點贊、評論、收藏，

更多精彩

太多了，去主頁看吧，