淺談函數式編程

来源:https://www.cnblogs.com/roushi17/archive/2019/12/04/fp_style.html
-Advertisement-
Play Games

函數式編程（Functional Programming）是一種編程風格，它是相對於指令式編程風格而言的，常見的面向對象編程就是指令式編程風格。 指令式編程是面向電腦硬體的抽象，有變數（對應著存儲單元），賦值語句（獲取、存儲指令），表達式（記憶體引用和算術運算）和控制語句（跳轉語句）。 而函數式編程 ...


函數式編程（Functional Programming）是一種編程風格，它是相對於指令式編程風格而言的，常見的面向對象編程就是指令式編程風格。

指令式編程是面向電腦硬體的抽象，有變數（對應著存儲單元），賦值語句（獲取、存儲指令），表達式（記憶體引用和算術運算）和控制語句（跳轉語句）。

而函數式編程是面向數學的抽象，將計算描述為一種表達式求值。這裡的函數實際就是數學中的函數，即自變數到因變數的映射。也就是說，一個函數的值僅決定於函數參數的值，不依賴其他狀態。

函數式編程是一種抽象程度很高的編程範式，純粹的函數式編程語言編寫的函數沒有變數，因此，任意一個函數，只要輸入是確定的，輸出就是確定的，這種純函數我們稱之為沒有副作用。而允許使用變數的程式設計語言，由於函數內部的變數狀態不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數是有副作用的。

在函數式語言當中，函數作為一等公民，可以在任何地方定義，在函數內或函數外，可以作為函數的參數或返回值，可以對函數進行組合，也可以將函數賦值給變數。嚴格意義上的函數式編程意味著不適用可變的變數，賦值，迴圈和其他命令式控制結構進行編程。

函數式編程風格帶來的好處是：

  1. 函數式編程使用不可變對象作為變數，不會修改變數的值，而是返回一個新的值，如此這樣，更容易理清頭緒，使得單元測試和調試更加容易；
  2. 可以很自由地傳遞不可變對象，但對於可變對象來說，傳遞給其他代碼之前，需要先建造一個以防萬一的副本；
  3. 一旦不可變對象完成構造以後，就不會有線程因為併發訪問而破壞對象內部狀態，因為根本沒有線程可以改變不可變對象的狀態；
  4. 不可變對象讓哈希表鍵值更安全，所以哈希表鍵要求必須是不可變對象，否則使用可變對象，如果對象狀態發生變化，那麼在哈希表中就找不到這個對象了；

具體到編程語言，Scala（靜態語言）和Python（動態語言）都能比較的支持函數式編程風格，但是它們都不是純函數式的，也就是說它們同時支持指令式風格和函數式風格。而Java基本是指令式風格，但自從Java8引入lambda表達式以後也開始部分支持函數式風格。函數式編程最典型的是諸如map, flatMap, reduce, filter等函數，它們的特點是支持某個函數作為上面這些函數的參數。

下麵分別以Java、Scala和Python舉例函數式編程，其中Java對函數式編程只是間接的支持（通過函數式介面），支持度比較有限，而Scala和Python就對函數式編程支持的比較好。

Java函數式編程舉例：

 1 package lxy.java.fp;
 2 
 3 import java.util.*;
 4 import java.util.function.*;
 5 
 6 
 7 public class FPDemo {
 8     //定義泛型方法，用以根據第二個參數指定的條件從第一個參數指定的集合中過濾部分元素，並返回過濾後的結果。這裡的第二個參數是一個函數式介面。
 9     public static <T> List <T> filter(List <T> list, Predicate <T> p) {
10         List <T> results = new ArrayList <>();
11         for (T s : list) {
12             if (p.test(s)) {
13                 results.add(s);
14             }
15         }
16         return results;
17     }
18 
19     public static void main(String[] args) {
20         List <String> myList = Arrays.asList("Hello", "Java", "Python", "Scala");
21 
22         //通過匿名類的方式
23         List <String> results = filter(myList, new Predicate <String>() {
24             public boolean test(String t) {
25                 return t.length() >= 5;
26             }
27         });
28         System.out.println("through anonymous class:");
29         System.out.println("strings with length more than 5:");
30         for (String result : results) {
31             System.out.println(result);
32         }
33 
34         //行為參數化，通過匿名函數（即lambda表達式）方式，
35         System.out.println("through lambda expression:");
36         System.out.println("strings with length more than 5:");
37         List <String> results2 = filter(myList, s -> s.length() >= 5);
38         results2.forEach(s -> System.out.println(s));
39 
40         //很容易地將過濾條件由字元串長度大於等於5改為字元串以字母a結尾，
41         // 這就是行為參數化，即將具體的邏輯（即行為或者函數）參數化，使得filter函數更加抽象，提高了代碼復用度
42         //否則需要寫2個filter函數，一個過濾出長度大於等於5的字元串，另一個過濾出以字元a結尾的字元串
43         System.out.println("strings ends with character 'a'");
44         List <String> results3 = filter(myList, s -> s.endsWith("a"));
45         results3.forEach(System.out::println);
46 
47         //Java流中的filter函數和map函數，註意這裡的filter是Java庫函數，和前面自定義的filter函數不一樣
48         System.out.println("strings with length more than 5 and its length:");
49         myList.parallelStream().filter(s -> s.length() >= 5).map(s -> "(" + s + ", " + s.length() + ")")
50                 .forEach(System.out::println);
51 
52         //高階函數
53         Function <Integer, Integer> f = (Integer x) -> x + 1;
54         Function <Integer, Integer> g = (Integer x) -> x * x;
55         Function <Integer, Integer> h = f.andThen(g);
56         Function <Integer, Integer> r = f.compose(g);
57 
58         System.out.println("higher-order function:");
59         System.out.println("h(2)=g(f(2))=" + h.apply(2));
60         System.out.println("r(2)=f(g(2))=" + r.apply(2));
61 
62     }
63 }

 

Scala函數式編程舉例：

 1 package lxy.scala.fp
 2 
 3 object FPDemo {
 4     //定義泛型方法，用以根據第二個參數指定的條件從第一個參數指定的列表中過濾部分元素，並返回過濾後的結果，結果類型仍然是List。
 5     //這裡的第二個參數是一個函數, 該函數輸入參數類型為T，返回值類型為Boolean
 6     def filter[T](list: List[T], f: T => Boolean) =
 7         for {e <- list if f(e) == true} yield e
 8 
 9     //高階函數，該函數定義為g(f(x))，其中函數f和g都是作為參數在調用該高階函數時指定的
10     def highOrderFunction1(x: Int, f: Int => Int, g: Int => Int) = g(f(x))
11 
12     //定義嵌套函數，針對每個參數，外層函數都會返回一個函數，即內層函數
13     //這裡factor是自由變數，number是綁定變數。
14     //閉包是一個函數，返回值依賴於聲明在函數外部的一個或多個變數
15     //函數multiplier返回的函數就是閉包，factor就是外部的變數，也叫自由變數，number是綁定變數(形式參數）
16     def multiplier(factor: Int): Int => Int = {
17         def multiplyByFactor(number: Int) = factor * number
18 
19         return multiplyByFactor
20     }
21 
22     //柯里化函數，類型是(Int)(Int) => Int
23     def multiplier2(factor: Int)(number: Int) = factor * number
24 
25     //這個函數實際跟multiplier效果是一樣的，每傳入一個參數factor，都會返回一個函數
26     //閉包是一個函數，返回值依賴於聲明在函數外部的一個或多個變數
27     //函數multiplier3返回的函數就是閉包，factor就是外部的變數，也叫自由變數，number是綁定變數(形式參數）
28     def multiplier3(factor: Int) = multiplier2(factor) _
29 
30     def main(args: Array[String]): Unit = {
31         val myList = List("Hello", "Java", "Python", "Scala")
32         println("strings with length more than 5")
33         filter(myList, (s: String) => s.length >= 5).foreach(s => println(s))
34 
35         println("strings ends with character 'a'")
36         filter(myList, (s: String) => s.endsWith("a")).foreach(println)
37 
38         println("strings with length more than 5 and its length:")
39         //這裡的filter不是自定義函數filter，而是庫函數，返回長度大於等於5的字元串以及對應的長度
40         myList.filter(_.length >= 5).map(s => (s, s.length)).foreach(println)
41 
42 
43         val result = highOrderFunction1(2, (x: Int) => x + 1, (x: Int) => x * x)
44         println("f(x)=x+1, g(x)=x*x, g(f(2))=" + result)
45 
46 
47         println("multiplier(2)=" + multiplier(2))
48         println("multiplier(2)(3)=" + multiplier(2)(3))
49         val double = multiplier(2)
50         println("double(3)=" + double(3))
51 
52         println("multiplier3(3)=" + multiplier3(3))
53         println("multiplier3(3)(4)=" + multiplier3(3)(4))
54         val triple = multiplier3(3)
55         println("triple(4)=" + triple(4))
56 
57     }
58 }

 

Python函數式編程舉例：

 1 #!/usr/bin/env python3
 2 # -*- coding: utf-8 -*-
 3 
 4 if __name__ == "__main__":
 5     """
 6         Usage: ./fp_demo.py
 7     """
 8 
 9     # 定義函數filter，第一個參數是列表，第二個參數是函數
10     def filter(list, f):
11         return [e for e in list if f(e) == True]
12 
13     # python中沒有foreach函數，自己定義一個，其中第一個參數是函數，第二個參數是迭代器（列表）
14     def foreach(f, iterator):
15         for item in iterator:
16             f(item)
17 
18     myList = ["Hello", "Java", "Python", "Scala"]
19     resultList = filter(myList, lambda e: len(e) >= 5)
20     print("strings with length more than 5", sep="\n")
21     foreach(lambda e: print(e, sep="\n"), resultList)
22 
23     resultList2 = filter(myList, lambda e: e.endswith("a"))
24     print("strings ends with character 'a'", sep="\n")
25     foreach(lambda e: print(e, sep="\n"), resultList2)
26 
27     # 這裡的map函數是python內置的
28     print("strings with length more than 5 and its length:", sep="\n")
29     foreach(lambda e: print(e, sep="\n"), map(lambda e: (e, len(e)), filter(myList, lambda e: len(e) >= 5)))
30 
31     # 高階函數，該函數定義為g(f(x))，其中函數f和g都是作為參數在調用該高階函數時指定的
32     def highOrderFunction1(x, f, g):
33         return g(f(x))
34 
35     # 該函數在下麵對highOrderFunction1函數的調用中被當做參數傳入
36     def f(x):
37         return x + 1
38 
39     # 第二個參數傳入上面定義的f函數，作為第三個參數的的函數採用的是匿名函數
40     result = highOrderFunction1(2, f, g=lambda x: x * x)
41     print("f(x)=x+1, g(x)=x*x, g(f(2))=%d" % result, sep="\n")
42 
43     # 定義嵌套函數，針對每個參數，外層函數都會返回一個函數，即內層函數
44     # 這裡factor是自由變數，number是綁定變數。
45     # 閉包是一個函數，返回值依賴於聲明在函數外部的一個或多個變數
46     # 函數multiplier返回的函數就是閉包，factor就是外部的變數，也叫自由變數，number是綁定變數(形式參數）
47     def multiplier(factor):
48         def multiplyByFactor(number):
49             return factor * number
50         return multiplyByFactor
51 
52 
53     print("multiplier(2)(3)=%s" % multiplier(2)(3))
54     # double是一個函數，它將輸入參數乘以2倍以後返回
55     double = multiplier(2)
56     print("double(3)=%s" % double(3))
57 
58     print("multiplier(3)(4)=%s" % multiplier(3)(4))
59     # triple是一個函數，它將輸入參數乘以3倍以後返回
60     triple = multiplier(3)
61     print("triple(4)=%s" % triple(4))
62 
63     # 第三個參數f是函數
64     def add(x, y, f):
65         return f(x) + f(y)
66 
67     print("2 ^ 2 + 3 ^2 = %s" % add(2, 3, lambda x: x * x))
68     print("(2 + 1) + (3 + 1) = %s" % add(2, 3, f))

 

最後來看一個數學題目，已知a<=b, 且a和b都是整數，求下麵三個公式的值。

 可以看到這三個公式分別是求a~b的和，a~b的平方和，a~b各自的階乘的和。可以看到三個公式是類似的，都是求和，只不過分別是對自身求和，對自身的平方求和以及對自身的階乘求和，也就是說這裡有3個計算邏輯，需要對這3個計算邏輯計算出來的數求和。如果是指令式編程風格，就只能寫三個函數來解決問題。但是如果採用函數式編程風格，就可以只寫一個通用的求和函數來解決該問題，因為可以將這3個計算邏輯（函數）作為參數傳給之前的通用求和函數。下麵分別用Java,Scala和Python來解決該問題。

Java代碼

 1 package lxy.java.fp;
 2 
 3 import java.util.function.*;
 4 
 5 
 6 public class Sum4Integers {
 7     //通用求和函數，其中f是一個函數式介面，它接收一個整型參數並返回一個整型數值
 8     //採用遞歸計算方法
 9     private static int sum(Function<Integer, Integer> f, int a, int b) {
10         if (a > b)
11             return 0;
12         else
13             return f.apply(a) + sum(f, a + 1, b);
14     }
15 
16     //求階乘函數,採用遞歸演算法，較複雜，不能作為匿名函數傳入上面的通用求和參數，因此需要預先定義
17     private static int factor(int x) {
18         if (x == 0)
19             return 1;
20         else
21             return x * factor(x - 1);
22     }
23 
24     //求公式一函數，即求a~b的和
25     //作為參數的函數就是返回變數自身，較簡單，採用匿名函數
26     static int sumInts(int a, int b) {
27         return sum(x -> x, a, b);
28     }
29 
30     //求公式二函數，即求a^2 ~ b^2的和
31     //作為參數的函數就是返回變數的平方，較簡單，採用匿名函數
32     static int sumSquares(int a, int b) {
33         return sum(x -> x * x, a, b);
34     }
35 
36     //求公式三函數，即求a! ~ b!的和
37     //作為參數的函數就是求變數的階乘，較複雜（本身是遞歸函數），採用定義好的函數factor
38     static int sumFactors(int a, int b) {
39         return sum(Sum4Integers::factor, a, b);
40     }
41 
42     public static void main(String[] args) {
43         System.out.println("1+2+3+4+5=" + sumInts(1, 5));
44         System.out.println("1^2+2^2+3^2+4^2+5^2=" + sumSquares(1, 5));
45         System.out.println("1!+2!+3!+4!+5!=" + sumFactors(1, 5));
46     }
47 
48 }

 

Scala代碼

 1 package lxy.scala.fp
 2 
 3 
 4 object Sum4Integers {
 5     //通用求和函數
 6     //採用遞歸計算方法
 7     private def sum(f: Int => Int, a: Int, b: Int): Int = if (a > b) 0 else f(a) + sum(f, a + 1, b)
 8 
 9     //求階乘函數,採用遞歸演算法，較複雜，不能作為匿名函數傳入上面的通用求和參數，因此需要預先定義
10     private def factor(x: Int): Int = if (x == 0) 1 else x * factor(x - 1)
11 
12     //求公式一函數，即求a~b的和
13     //作為參數的函數就是返回變數自身，較簡單，採用匿名函數
14     def sumInts(a: Int, b: Int) = sum(x => x, a, b)
15 
16     //求公式二函數，即求a^2 ~ b^2的和
17     //作為參數的函數就是返回變數的平方，較簡單，採用匿名函數
18     def sumSquares(a: Int, b: Int) = sum(x => x * x, a, b)
19 
20     //求公式三函數，即求a! ~ b!的和
21     //作為參數的函數就是求變數的階乘，較複雜（本身是遞歸函數），採用定義好的函數factor
22     def sumFactors(a: Int, b: Int) = sum(factor, a, b)
23 
24     def main(args: Array[String]): Unit = {
25         println("1+2+3+4+5=" + sumInts(1, 5))
26         println("1^2+2^2+3^2+4^2+5^2=" + sumSquares(1, 5))
27         println("1!+2!+3!+4!+5!=" + sumFactors(1, 5))
28     }
29 
30 }

 

Python代碼

 1 #!/usr/bin/env python3
 2 # -*- coding: utf-8 -*-
 3 
 4 if __name__ == "__main__":
 5     """
 6         Usage: ./sum_integers.py
 7     """
 8 
 9     # 通用求和函數，採用遞歸計算方法
10     def sum(f, a, b):
11         if a > b:
12             return 0
13         else:
14             return f(a) + sum(f, a + 1, b)
15 
16     # 求階乘函數,採用遞歸演算法，較複雜，不能作為匿名函數傳入上面的通用求和參數，因此需要預先定義
17     def factor(x):
18         if x == 0:
19             return 1
20         else:
21             return x * factor(x - 1)
22 
23     # 求公式一函數，即求a~b的和
24     # 作為sum函數的第一個參數的函數就是返回變數自身，較簡單，採用匿名函數
25     def sumInts(a, b):
26         return sum(lambda x: x, a, b)
27 
28     # 求公式二函數，即求a^2 ~ b^2的和
29     # 作為sum函數的第一個參數的函數就是返回變數的平方，較簡單，採用匿名函數
30     def sumSquares(a, b):
31         return sum(lambda x: x * x, a, b)
32 
33     # 求公式三函數，即求a! ~ b!的和
34     # 作為sum函數的第一個參數的函數就是求變數的階乘，較複雜（本身是遞歸函數），採用定義好的函數factor
35     def sumFactors(a, b):
36         return sum(factor, a, b)
37 
38     print("1+2+3+4+5=%d" % sumInts(1, 5))
39     print("1^2+2^2+3^2+4^2+5^2=%d" % sumSquares(1, 5))
40     print("1!+2!+3!+4!+5!=%d" % sumFactors(1, 5))

 

從上面解決同一個問題的代碼量比較來看，Scala和Python比較短，而Java比較長，而且Java對函數式編程的支持目前還比較有限，因此函數式編程建議採用Scala或者Python。

 

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • linux學習第一周
    1. 按系列羅列Linux的發行版，並描述不同發行版之間的聯繫與區別 2. 安裝Centos7.6操作系統，創建一個自己名字的用戶名，並可以正常登錄，將主要步驟截圖。 3. 配置環境變數，實現執行history的時候可以看到執行命令的時間。 4. 總結Linux哲學思想。 5. 總結Linux常用命 ...
  • 新手Linux之路之Deepin
    用了很久的Window，心血來潮想換個系統，於是就開始踩坑Linux之路。 系統為deepin 首先基本的 設置root密碼 $：sudo passwd root [sudo] password for you: > 輸入密碼（當前用戶密碼） Enter new UNIX password: > 設 ...
  • oracle 觸發器trigger（主鍵自增長）
    觸發器trigger 觸發器我們也可以認為是存儲過程，是一種特殊的存儲過程。 存儲過程：有輸入參數和輸出參數，定義之後需要調用 觸發器：沒有輸入參數和輸出參數，定義之後無需調用，在適當的時候會自動執行。 適當的時候：觸發器與表相關，當我們對這個相關的表中的數據進行DDL（數據的添加、修改、刪除）操作 ...
  • sql server的簡單分頁
    --顯示前條數據 select top(4) * from students; --pageSize:每頁顯示的條數 --pageNow:當前頁 select top(pageSize) * from students where sno not in (select top(pageSize*(p ...
  • sqlserver查詢（子查詢，全連接，等值連接，自然連接，左右連，交集，並集，差集）
    --部門表 create table dept( deptno int primary key,--部門編號 dname nvarchar(30),--部門名 loc nvarchar(30)--地址 ); --雇員表 create table emp( empno int primary key, ...
  • sql server查詢（SELECT ，where，distinct，like 查詢，in，is null，group by 和having，order by，as）
    基本查詢： 實例表 1 示例表 2 --部門表 3 4 create table dept( 5 6 deptno int primary key,--部門編號 7 8 dname nvarchar(30),--部門名 9 10 loc nvarchar(30)--地址 11 12 ); 13 14 ...
  • sql server 增刪改（查太多了）
    表： 學生（*學號，姓名，性別，年齡，專業） create table student( sno char(13) primary key, sname varchar(20) not null, ssex char(2), sage smallint, sdept varchar(30) ); 課 ...
  • SQL Server2017 安裝完成後找不到啟動項解決方案
    很多用於當SQL Server2017 安裝完成後開始菜單找不到啟動項無法啟動SQL Server2017 其實你只需要安裝一下SSMS-Setup-CHS就可以了 安裝完成之後就有了 SSMS-Setup-CHS 下載鏈接： 鏈接：https://pan.baidu.com/s/18EcH16Ok ...
一周排行
    -Advertisement-
    Play Games
  • UOS 開啟 VisualStudio 遠程調試 .NET 應用之旅
    前言 在我們開發過程中基本上不可或缺的用到一些敏感機密數據，比如SQL伺服器的連接串或者是OAuth2的Secret等，這些敏感數據在代碼中是不太安全的，我們不應該在源代碼中存儲密碼和其他的敏感數據，一種推薦的方式是通過Asp.Net Core的機密管理器。 機密管理器 在 ASP.NET Core ...
  • C# - 能否讓 SortedSet.RemoveWhere 內傳入的委托非同步執行
    新改進提供的Taurus Rpc 功能，可以簡化微服務間的調用，同時可以不用再手動輸出模塊名稱，或調用路徑，包括負載均衡，這一切，由框架實現並提供了。新的Taurus Rpc 功能，將使得服務間的調用，更加輕鬆、簡約、高效。 ...
  • 順序棧的介面程式
    順序棧的介面程式 目錄順序棧的介面程式頭文件創建順序棧入棧出棧利用棧將10進位轉16進位數驗證 頭文件 #include <stdio.h> #include <stdbool.h> #include <stdlib.h> 創建順序棧 // 指的是順序棧中的元素的數據類型，用戶可以根據需要進行修改 ...
  • mORMot2 獲取數據集1
    前言 整理這個官方翻譯的系列，原因是網上大部分的 tomcat 版本比較舊，此版本為 v11 最新的版本。 開源項目 從零手寫實現 tomcat minicat 別稱【嗅虎】心有猛虎，輕嗅薔薇。 系列文章 web server apache tomcat11-01-官方文檔入門介紹 web serv ...
  • 萬字長文總結與剖析C語言關鍵字 -- <<C語言深度解剖>>
    C總結與剖析:關鍵字篇 -- <<C語言深度解剖>> 目錄C總結與剖析:關鍵字篇 -- <<C語言深度解剖>>程式的本質:二進位文件變數1.變數:記憶體上的某個位置開闢的空間2.變數的初始化3.為什麼要有變數4.局部變數與全局變數5.變數的大小由類型決定6.任何一個變數,記憶體賦值都是從低地址開始往高地 ...
  • 【Flink入門修煉】2-3 Flink Checkpoint 原理機制
    如果讓你來做一個有狀態流式應用的故障恢復，你會如何來做呢？ 單機和多機會遇到什麼不同的問題？ Flink Checkpoint 是做什麼用的？原理是什麼？ ...
  • C++ 多級繼承與多重繼承：代碼組織與靈活性的平衡
    C++ 多級繼承 多級繼承是一種面向對象編程（OOP）特性，允許一個類從多個基類繼承屬性和方法。它使代碼更易於組織和維護，並促進代碼重用。 多級繼承的語法 在 C++ 中，使用 : 符號來指定繼承關係。多級繼承的語法如下： class DerivedClass : public BaseClass1 ...
  • 圖文結合手把手教你創建SpringCloud項目
    前言 什麼是SpringCloud？ Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的開發便利性簡化了分散式系統的開發，比如服務註冊、服務發現、網關、路由、鏈路追蹤等。Spring Cloud 並不是重覆造輪子，而是將市面上開發得比較好的模塊集成進去，進行封裝，從 ...
  • 類模板的常見用法
    class_template 類模板和函數模板的定義和使用類似，我們已經進行了介紹。有時，有兩個或多個類，其功能是相同的，僅僅是數據類型不同。類模板用於實現類所需數據的類型參數化 template<class NameType, class AgeType> class Person { publi ...
  • system-v IPC共用記憶體通信
    目錄system v IPC簡介共用記憶體需要用到的函數介面shmget函數--獲取對象IDshmat函數--獲得映射空間shmctl函數--釋放資源共用記憶體實現思路註意 system v IPC簡介 消息隊列、共用記憶體和信號量統稱為system v IPC(進程間通信機制)，V是羅馬數字5，是UNI ...
所有分類