函數式編程(FunctionalProgramming)

基于lambda演算的一種編程方式

程序中只有函數

函數可以作為參數，同樣可以作為返回值

純函數式編程語言： LISP， Haskell

Python函數式編程只是借鑒函數式編程的一些特點，可以理解成一半函數式一半Python

需要理解

高階函數

返回函數

匿名函數

裝飾器

偏函數

lambda表達式

函數： 最大程度復用代碼

存在問題： 如果函數很小，很短，則會造成啰嗦

如果函數被調用次數少，則會造成浪費

對于閱讀者來說，造成閱讀流程的被迫中斷

lambda表達式（匿名函數）：

一個表達式，函數體相對簡單

不是一個代碼塊，僅僅是一個表達式

可以有參數，有多個參數也可以，用逗號隔開

# lambda表達式的用法

# 1. 以lambda開頭

# 2. 緊跟一定的參數（如果有的話）

# 3. 參數后用冒號和表達式主題隔開

# 4. 只是一個表達式，所以，沒有return

# 5. 使用 的時候以函數的方式使用fun(v1,v2....)

# 計算一個數字的100倍數

# 因為就是一個表達式，所以沒有return

stm = lambda x: 100 * x

# 使用上跟函數調用一模一樣

stm(89)

高階函數

把函數作為參數使用的函數，叫高階函數

函數名稱是變量，則應該可以被當做參數傳入另一個函數

def aa(n):

return n*10

def bb(n,f):

return f(n)*3

bb(3,aa)

系統高階函數-map

原意就是映射，即把集合或者列表的元素，每一個元素都按照一定規則進行操作，生成一個新的列表或者集合

map函數是系統提供的具有映射功能的函數，返回值是一個迭代對象

map(函數,要處理的列表)

map(lambda x:x*10,[i for i in range(10)] )

reduce

原意是歸并，縮減,把一個可迭代對象最后歸并成一個結果

reduce 需要導入functools包：from functools import reduce

對于作為參數的函數要求： 必須有且僅有兩個參數，必須由返回結果

reduce([1,2,3,4,5]) == f( f(f(f(1,2),3), 4),5)

rst = reduce( lambda x,y:x+y, [1,2,3,4,5,6] )

filter 函數

過濾函數： 對一組數據進行過濾，符合條件的數據會生成一個新的列表并返回

跟map相比較：

相同：都對列表的每一個元素逐一進行操作

不同：

map會生成一個跟原來數據想對應的新隊列

filter只有符合條件的才會進入新的數據集合

filter函數用法：

利用給定函數進行判斷，過濾函數返回值一定是個布爾值

調用格式： filter(f, data), f是過濾函數， data是數據,返回一個可迭代的filter對象

rst = filter(lambda x:x%2==0, [1,3,4,5,8,9])

sort-排序

把一個序列按照給定算法進行排序

key: 在排序錢對每一個元素進行key函數運算，可以理解成按照key函數定義的邏輯進行排序

python2 和 python3 相差巨大

key: key=abs絕對值， key=str.lower：小寫。。。。

返回函數

把一個函數當做返回值返回

# 返回函數的例子

# args:參數列表

# 1 myF4定義函數，返回內部定義的函數myF5

# 2. myF5使用了外部變量，這個變量是myF4的參數

def myF4( *args):

def myF5():

rst = 0

for n in args:

rst += n

return rst

return myF5

# 執行

f5 = myF4(1,2,3,4,5,6,7,8,9,0)

f5()

閉包（closure)

當一個函數在內部定義函數，并且內部的函數使用外部函數的參數或者局部變量，當內部函數被當做返回值的時候，相關參數和變量保存在返回的函數中，這種結果，叫閉包

上面定義的myF4是一個標準閉包結構

# 閉包常見坑

def count():

# 定義列表，列表里存放的是定義的函數

fs = []

for i in range(1,4):

# 定義了一個函數f

# f是一個閉包結構

def f():

return i*i

fs.append(f)

return fs

f1,f2,f3 = count()

#期望出現，1,4,9實際是9,9,9,

出現的問題：

造成上述狀況的原因是,返回函數引用了變量i， i并非立即執行，而是等到三個函數都返回的時候才統一使用，此時i已經變成了3，最終調用的時候，都返回的是 3*3

此問題描述成：返回閉包時，返回函數不能引用任何循環變量

解決方案： 再創建一個函數，用該函數的參數綁定循環變量的當前值，無論該循環變量以后如何改變，已經綁定的函數參數值不再改變

裝飾器(Decrator)

在不改動函數代碼的基礎上無限制擴展函數功能的一種機制，本質上講，裝飾器是一個返回函數的高階函數

裝飾器的使用： 使用@語法， 即在每次要擴展到函數定義前使用@+函數名

實際上是在函數具體執行之前，執行裝飾器里面的內容

import time

# 高階函數，以函數作為參數

def printTime(f):

def wrapper(*args, **kwargs):

print("Time: ", time.ctime())

return f(*args, **kwargs)

return wrapper

@printTime

def add(x,y):

return x+y

print(add(77,44))

偏函數

參數固定的函數，相當于一個由特定參數的函數體

functools.partial的作用是，把一個函數某些函數固定，返回一個新函數

import functools

#實現上面int16的功能

int16 = functools.partial(int, base=16)

int16("12345")

高級內置函數

zip

把兩個可迭代內容生成一個可迭代的tuple元素類型組成的內容,如果元素不對等，取能匹配的最大值

# zip 案例

l1 = [ 1,2,3,4,5]

l2 = [11,22,33,44]

z = zip(l1, l2)

for i in z:

print(i)

#輸出

(1, 11)

(2, 22)

(3, 33)

(4, 44)

enumerate

跟zip功能比較像

對可迭代對象里的每一元素，配上一個索引，然后索引和內容構成tuple類型

l1 = [11,22,33,44]

em = enumerate(l1)

l2 = [i for i in em]

print(l2)

#輸出：

[(0, 11), (1, 22), (2, 33), (3, 44)]

collections模塊

namedtuple

是一個可命名的tuple

import collections

Point = collections.namedtuple("Point", ["x", "y"])

p = Point(11, 22)

deque

比較方便的解決了頻繁刪除插入帶來的效率問題

from collections import deque

q = deque(["a", "b", "c"])

q.append("d")

q.appendleft("x")

## deque(["x", "a", "b", "c", "d"])

defaultdict

當直接讀取dict不存在的屬性時，直接返回默認值

第一個參數要為函數

func = lambda: "劉大拿"

d2 = defaultdict(func)

Counter

統計字符串個數

```c = Counter("abcdefgabcdeabcdabcaba")

print(c)

s = ["liudana", "love", "love", "love", "love", "wangxiaona"]

c = Counter(s)

總結

以上是生活随笔為你收集整理的python函数式编程读取数据-python学习笔记9：函数式编程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。