python中函數式編程是什么

小編給大家分享一下python中函數式編程是什么，希望大家閱讀完這篇文章后大所收獲，下面讓我們一起去探討吧！

函數式編程理解：

編寫代碼的時候，函數式編程更多的是從聲明式的方法，而傳統的編程更多的是命令式的方法。例如，上面的篩選學生年紀，傳統的編程思想是，我創建了什么，我循環了什么，我判斷了什么，得出了什么結果；函數式編程的思想是，我聲明了一個篩選的函數，我聲明了一個判斷的函數，我把這兩個函數結合起來，得出了一個結果。

關于純函數

在函數式編程的概念中，有一個重要的概念是純函數，那么什么是純函數呢?

我們用代碼來解釋什么是純函數：

const z = 10;
add(x, y) {
 return x + y;
}
復制代碼
上面的add函數就是一個純函數，它讀取x和y兩個參數的值，返回它們的和，并且不會受到全局的z變量的影響
 
把這個函數改一下
const z = 10;
add(x, y) {
 return x + y + z;
}
復制代碼

這個函數就變成了不純的函數了，因為它返回的值會受到全局的z的影響，換句話說，這個函數會被外部環境影響，我們就得出了第一個判斷是否純函數的重要依據——純函數不會受到外部環境的影響。

再用splice和slice來解釋一下：

var xs = [1,2,3,4,5];
// 純的
xs.slice(0,3);
//=> [1,2,3]
xs.slice(0,3);
//=> [1,2,3]
xs.slice(0,3);
//=> [1,2,3]
// 不純的
xs.splice(0,3);
//=> [1,2,3]
xs.splice(0,3);
//=> [4,5]
xs.splice(0,3);
//=> []
復制代碼

slice收到同樣的參數，每次返回相同的值，所以是純函數,splice收到同樣的參數，每次返回不同的值，所以不是純函數，我們就得出了第二個判斷是否純函數的重要依據——純函數相同的輸入，永遠會得到相同的輸出。

總結：

'純函數是這樣一種函數，即相同的輸入，永遠會得到相同的輸出，而且沒有任何可觀察的副作用'
復制代碼

關于柯里化

柯里化的概念很簡單：只傳遞給函數一部分參數來調用它，讓它返回一個函數去處理剩下的參數。

const add = x => y => x + y;
add(1)(2);
// => 3
復制代碼

上面的例子，就是一個很典型的柯里化函數，在我們第一調用的時候，接收了第一次傳入的參數（用閉包記住），返回了一個新的函數；在第二次調用的時候，接收第二次傳入的參數，并且和第一次傳入的函數相加，返回它們的和。

運用上面的思想編寫一個的柯里化函數：

currying(fn, ...args1) {
 // '判斷傳入的參數是否滿足傳入函數需要的參數，比如說add函數需要兩個參數相加，那么判斷是否傳入了兩個參數，滿足調用傳入函數計算結果'
 if (args1.length >= fn.length) {
 console.log(args1, '--1--');
 return fn(...args1);
 }
 // '不滿足返回一個新的函數，繼續調用柯里化函數，傳入保存的第一次傳入的函數，傳入保存的第一次傳入的參數，傳入第二次傳入的參數，繼續上面的判斷邏輯，返回計算結果'
 return (...args2) => {
 console.log(args2, '--2--');
 return currying(fn, ...args1, ...args2);
 };
},
// 定義一個一般函數
const add = (x, y) => x + y;
// 使用
const increment = currying(add, 1);
console.log(increment(2));
const addTen = currying(add, 10);
console.log(addTen(2));
// => [2] --2--
// => [1,2] --1--
// => 3
// => [2] --2--
// => [10,2] --1--
// => 12
復制代碼

柯里化函數比較重要的思想是：

多次判斷傳入的參數是否滿足計算需求，滿足，返回計算結果，如果不滿足，繼續返回一個新的柯里化函數

關于代碼組合

首先，先寫一個簡單的組合函數：

const compose = (f, g) => x => f(g(x));

這個組合函數接收兩個函數當作參數，然后返回一個新的函數，x是兩個函數之間都要使用的值，比如說：

const compose = (...fns) => (...args) => fns.reduceRight((res, fn) => [fn.call(null, ...res)], args)[0];
// 使用，實現一個功能，字符串變成大寫，加上個感嘆號，還要截取一部分，再在前面加上注釋
const toUpperCase = x => x.toUpperCase();
const exclaim = x => `${x}!`;
const head = x => `slice is: ${x}`;
const reverse = x => x.slice(0, 7);
const shout = compose(exclaim, toUpperCase, head, reverse)
shout('my name is maya')
// => SLICE IS: MY NAME!
復制代碼

組合的原理其實就是數學中的結合律：

(a + b) + c = a + (b + c)

對組合的理解是：

組合是什么，組合就是運用了數學里的結合律，像是搭積木一樣，把不同的函數聯系起來，讓數據在里面流動

在各種庫里面都有組合的函數，lodash，underscore，ramda等等，比如在underscore里面，組合是這樣的：

 // Returns a function that is the composition of a list of functions, each
 // consuming the return value of the function that follows.
 _.compose = function() {
 var args = arguments;
 var start = args.length - 1;
 return function() {
 var i = start;
 var result = args[start].apply(this, arguments);
 while (i--) result = args[i].call(this, result);
 return result;
 };
 };
復制代碼

相信大家到這里已經初步了解了函數式編程的概念了，那么我們怎么使用函數式編程的方式寫代碼呢，舉個例子：

// 偽代碼，思路
// 比如說，我們請求后臺拿到了一個數據，然后我們需要篩選幾次這個數據, 取出里面的一部分，并且排序
// 數據
const res = {
 status: 200,
 data: [
 {
 id: xxx,
 name: xxx,
 time: xxx,
 content: xxx,
 created: xxx
 },
 ...
 ]
}
// 封裝的請求函數
const http = xxx;
// '傳統寫法是這樣的'
http.post
 .then(res => 拿到數據)
 .then(res => 做出篩選)
 .then(res => 做出篩選)
 .then(res => 取出一部分)
 .then(res => 排序)
 
// '函數式編程是這樣的'
// 聲明一個篩選函數
const a = curry()
// 聲明一個取出函數
const b = curry()
// 聲明一個排序函數
const c = curry()
// 組合起來
const shout = compose(c, b, a)
// 使用
shout(http.post)
復制代碼

如果想要在項目里面正式使用函數式編程有這樣幾個步驟：

 1、先嘗試使用ES6自帶的高階函數

2、熟悉了ES6自帶的高階函數后，可以自己嘗試寫幾個高階函數

3、在這個過程中，盡量使用純函數編寫代碼

4、對函數式編程有所了解之后，嘗試使用類似ramda的庫來編寫代碼

5、在使用ramda的過程中，可以嘗試研究它的源代碼

6、嘗試編寫自己的庫，柯里化函數，組合函數等

看完了這篇文章，相信你對python中函數式編程是什么有了一定的了解，想了解更多相關知識，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！