Python 函數 · ZetCode 中文系列教程

# Python 函數 > 原文： [http://zetcode.com/lang/python/functions/](http://zetcode.com/lang/python/functions/) 在 Python 編程教程的這一部分中，我們介紹了 Python 中的函數。 ## Python 函數定義函數是用于執行特定操作的可重用代碼塊。使用函數的優點是： * 減少代碼重復 * 將復雜的問題分解成更簡單的部分 * 提高代碼的清晰度 * 重用代碼 * 信息隱藏 Python 中的函數是一等公民。這意味著函數與 Python 中的其他對象具有同等的狀態。可以將函數分配給變量，存儲在集合中或作為參數傳遞。這給語言帶來了額外的靈活性。 ## Python 函數類型函數有兩種基本類型：內置函數和用戶定義函數。內置函數是 Python 語言的一部分；例如`dir()`，`len()`或`abs()`。用戶定義的函數是使用`def`關鍵字創建的函數。 ## Python 創建函數使用`def`關鍵字創建一個函數。函數塊中的語句必須縮進。 ```py def function(): pass ``` `def`關鍵字后跟帶有圓括號和冒號的函數名稱。縮進語句形成函數的主體。該函數稍后在需要時執行。我們說我們調用函數。如果我們調用一個函數，則會執行函數體內的語句。在調用函數之前，它們不會執行。 ```py myfunc() ``` 要調用函數，我們用圓括號指定函數名稱。 `ret.py` ```py #!/usr/bin/env python """ The ret.py script shows how to work with functions in Python. Author: Jan Bodnar ZetCode, 2019 """ def show_module_name(): print(__doc__) def get_module_file(): return __file__ a = show_module_name() b = get_module_file() print(a, b) ``` 腳本頂部的字符串稱為文檔字符串。它記錄了當前腳本。我們放入 Python 代碼的文件稱為模塊。我們定義兩個函數。第一個函數打印模塊文檔字符串。第二個返回模塊的路徑。函數可能會或可能不會返回值。如果函數沒有返回值，則它隱式返回`None`。 `__doc__`和`__file__`是特殊的狀態屬性。請注意，屬性的兩側都有兩個下劃線。 ```py $ ./ret.py The ret.py script shows how to work with functions in Python. Author: Jan Bodnar ZetCode, 2019 None C:/Users/Jano/PycharmProjects/Simple/simple.py ``` 這是程序的輸出。函數的定義必須先于其用法。否則，口譯員會抱怨`NameError`。 `func_prec.py` ```py #!/usr/bin/env python # func_prec.py def f1(): print("f1()") f1() #f2() def f2(): print("f2()") ``` 在上面的示例中，我們有兩個函數定義。一行被注釋。函數調用不能超出其定義。 ```py #f2() def f2(): print("f2()") ``` 僅在定義后才能調用`f2()`。取消注釋該行，我們得到一個`NameError`。 ## 在哪里定義函數可以在模塊，類或其他函數中定義函數。在類內部定義的函數稱為方法。 `defining.py` ```py #!/usr/bin/env python # defining.py class Some(): @staticmethod def f(): print("f() method") def f(): print("f() function") def g(): def f(): print("f() inner function") f() Some.f() f() g() ``` 在此示例中，我們在三個不同的位置定義了`f()`函數。 ```py # defining.py class Some(): @staticmethod def f(): print("f() method") ``` 靜態方法在`Some`類中用裝飾器定義。 ```py def f(): print("f() function") ``` 該函數在模塊中定義。 ```py def g(): def f(): print("f() inner function") f() ``` 此處，`f()`函數在另一個`g()`函數內部定義。這是一個內部函數。 ```py Some.f() f() g() ``` 通過使用方括號指定類名稱，點運算符和函數名稱來調用靜態方法。其他函數使用其名稱和方括號來調用。 ```py $ ./defining.py f() method f() function f() inner function ``` 這是輸出。 ## Python 函數是對象 Python 中的函數是對象。它們可以像 Python 中的其他對象一樣進行操作。因此，職能被稱為頭等公民。在其他 OOP 語言（例如 Java 或 C# ）中，情況并非如此。 `fun_obj.py` ```py #!/usr/bin/env python # fun_obj.py def f(): """This function prints a message """ print("Today it is a cloudy day") print(isinstance(f, object)) print(id(f)) print(f.__doc__) print(f.__name__) ``` 在此腳本中，我們表明我們的函數也是一個對象。 ```py def f(): """This function prints a message """ print("Today it is a cloudy day") ``` 我們定義一個`f()`函數。它將消息打印到控制臺。它還具有一個文檔字符串。 ```py print(isinstance(f, object)) ``` `isinstance()`函數檢查`f()`函數是否是`object`的實例。 Python 中的所有對象均從該基本實體繼承。 ```py print(id(f)) ``` Python 中的每個對象都有一個唯一的 ID。 `id()`函數返回對象的 ID。 ```py print(f.__doc__) print(f.__name__) ``` 對象可能具有屬性；我們打印函數的兩個屬性：`__doc__`和`__name__`。 ```py $ ./fun_obj.py True 140353774014536 This function prints a message f ``` 這是程序的輸出。函數可以存儲在集合中并傳遞給其他函數。 `fun_coll.py` ```py #!/usr/bin/env python # fun_coll.py def f(): pass def g(): pass def h(f): print(id(f)) a = (f, g, h) for i in a: print(i) h(f) h(g) ``` 我們定義了三個函數。我們將它們放在一個元組中，然后將它們傳遞給函數。 ```py a = (f, g, h) for i in a: print(i) ``` 我們將三個函數對象放在一個元組中，并使用`for`循環遍歷它。 ```py h(f) h(g) ``` 我們將`f()`和`g()`函數傳遞給`h()`函數。 ```py $ ./fun_coll.py <function f at 0x0000015B998E9D08> <function g at 0x0000015B998E9E18> <function h at 0x0000015B998E9840> 1492929912072 1492929912344 ``` 這是`fun_coll.py`程序的輸出。 ## Python 中的三種函數從特定的角度來看，我們可以辨別出三種函數。始終可供使用的函數，必須導入的外部模塊中包含的函數以及由程序員使用`def`關鍵字定義的函數。 `three_kinds.py` ```py #!/usr/bin/env python from math import sqrt def cube(x): return x * x * x print(abs(-1)) print(cube(9)) print(sqrt(81)) ``` 上面的代碼中存在三種函數。 ```py from math import sqrt ``` `sqrt()`函數是從數學模塊導入的。 ```py def cube(x): return x * x * x ``` `cube()`函數是一個自定義函數。 ```py print(abs(-1)) ``` `abs()`函數是易于訪問的內置函數。它是語言核心的一部分。 ## Python `return`關鍵字創建一個函數來執行特定任務。通常，這種任務會產生結果。 `return`關鍵字用于從函數返回值。函數可能會也可能不會返回值。如果一個函數沒有`return`關鍵字，它將發送`None`。 `returning.py` ```py #!/usr/bin/env python # returning.py def show_message(msg): print(msg) def cube(x): return x * x * x x = cube(3) print(x) show_message("Computation finished.") print(show_message("Ready.")) ``` 我們定義了兩個函數。一個使用`return`關鍵字，另一個則不使用。 ```py def show_message(msg): print(msg) ``` `show_message()`函數不會顯式返回值。它在控制臺上顯示一條消息。 ```py def cube(x): return x * x * x ``` `cube()`函數計算一個表達式，并使用`return`關鍵字返回其結果。 ```py x = cube(3) ``` 在這一行中，我們稱為`cube()`函數。返回`cube()`函數的計算結果，并將其分配給`x`變量。現在保存結果值。 ```py show_message("Computation finished.") ``` 我們以消息為參數調用`show_message()`函數。該消息將打印到控制臺。我們不期望此函數有值。 ```py print(show_message("Ready.")) ``` 此代碼產生兩行。一種是通過`show_message()`函數打印的消息。另一個是`None`值，該值由沒有`return`語句的函數隱式發送。 ```py $ ./returning.py 27 Computation finished. Ready. None ``` 這是示例輸出。我們可以從函數中發送多個值。 `return`關鍵字之后的對象用逗號分隔。 `returning2.py` ```py #!/usr/bin/env python # returning2.py n = [1, 2, 3, 4, 5] def stats(x): _mx = max(x) _mn = min(x) _ln = len(x) _sm = sum(x) return _mx, _mn, _ln, _sm mx, mn, ln, sm = stats(n) print(stats(n)) print(mx, mn, ln, sm) ``` 有`stats()`函數的定義。此函數返回四個值。 ```py return _mx, _mn, _ln, _sm ``` `return`關鍵字發回四個數字。這些數字用逗號分隔。實際上，我們已經發送了包含這四個值的元組。我們也可以返回列表而不是元組。 ```py mx, mn, ln, sm = stats(n) ``` 返回的值分配給局部變量。 ```py $ ./returning2.py (5, 1, 5, 15) 5 1 5 15 ``` 這是輸出。 ## Python 函數重新定義 Python 本質上是動態的。可以重新定義已經定義的函數。 `redefinition.py` ```py #!/usr/bin/env python # redefinition.py from time import gmtime, strftime def show_message(msg): print(msg) show_message("Ready.") def show_message(msg): print(strftime("%H:%M:%S", gmtime())) print(msg) show_message("Processing.") ``` 我們定義一個`show_message()`函數。稍后，我們提供相同函數的新定義。 ```py from time import gmtime, strftime ``` 從時間模塊中，我們導入兩個函數，用于計算當前時間。 ```py def show_message(msg): print(msg) ``` 這是函數的第一個定義。它僅將消息打印到控制臺。 ```py def show_message(msg): print(strftime("%H:%M:%S", gmtime())) print(msg) ``` 在源代碼的后面，我們設置了`showMessage()`函數的新定義。該消息之前帶有時間戳。 ```py $ ./redefinition.py Ready. 23:49:33 Processing. ``` 這是輸出。 ## Python 函數參數大多數函數接受參數。參數是發送到函數的值。這些函數處理這些值并有選擇地返回一些值。 `fahrenheit.py` ```py #!/usr/bin/env python # fahrenheit.py def C2F(c): return c * 9/5 + 32 print(C2F(100)) print(C2F(0)) print(C2F(30)) ``` 在我們的示例中，我們將攝氏溫度轉換為華氏溫度。 `C2F()`函數接受一個參數`c`，即攝氏溫度。 ```py $ ./fahrenheit.py 212 32 86 ``` Python 函數中的參數可能具有隱式值。如果未提供任何值，則使用隱式值。 `fun_implicit.py` ```py #!/usr/bin/env python # fun_implicit.py def power(x, y=2): r = 1 for i in range(y): r = r * x return r print(power(3)) print(power(3, 3)) print(power(5, 5)) ``` 在這里，我們創建了冪函數。該函數有一個帶有隱式值的參數。我們可以使用一個或兩個參數來調用該函數。 ```py $ ./fun_implicit.py 9 27 3125 ``` Python 函數可以使用關鍵字指定其參數。這意味著在調用函數時，我們同時指定了關鍵字和值。當我們有多個參數并且不使用關鍵字而使用它們時，傳遞這些參數的順序至關重要。如果我們期望在沒有關鍵字的函數中使用名稱，年齡或性別，則無法更改其順序。如果使用關鍵字，我們可以。 `fun_keywords.py` ```py #!/usr/bin/env python # fun_keywords.py def display(name, age, sex): print("Name: ", name) print("Age: ", age) print("Sex: ", sex) display("Lary", 43, "M") display("Joan", 24, "F") ``` 在此示例中，我們指定參數的順序很重要。否則，我們將得到錯誤的結果。 ```py $ ./fun_keywords.py Name: Lary Age: 43 Sex: M Name: Joan Age: 24 Sex: F ``` `fun_keywords2.py` ```py #!/usr/bin/env python # fun_keywords2.py def display(name, age, sex): print("Name: ", name) print("Age: ", age) print("Sex: ", sex) display(age=43, name="Lary", sex="M") display(name="Joan", age=24, sex="F") ``` 現在我們用它們的關鍵字來調用函數。可以更改順序，盡管不建議這樣做。請注意，我們不能在關鍵字參數之后使用非關鍵字參數。這將導致語法錯誤。 ```py display("Joan", sex="F", age=24) ``` 這是法律構想。非關鍵字參數后可以跟關鍵字參數。 ```py display(age=24, name="Joan", "F") ``` 這將導致語法錯誤。非關鍵字參數不能跟在關鍵字參數之后。 Python 中的函數可以接受任意數量的參數。 `arbitrary_args.py` ```py #!/usr/bin/env python # arbitrary_args.py def do_sum(*args): """Function returns the sum of all values""" r = 0 for i in args: r += i return r print(do_sum.__doc__) print(do_sum(1, 2, 3)) print(do_sum(1, 2, 3, 4, 5)) ``` 我們使用`*`運算符表示該函數接受任意數量的參數。 `do_sum()`函數返回所有參數的總和。函數主體中的第一個字符串稱為函數文檔字符串。用于記錄函數。該字符串必須用三引號引起來。 ```py $ ./arbitrary_args.py Function returns the sum of all values 6 15 ``` 我們還可以在函數中使用`**`構造。在這種情況下，該函數將接受字典。字典有任意長度。然后，我們通常可以照常解析字典。 `details.py` ```py #!/usr/bin/env python # details.py def display(**details): for i in details: print(f"{i}: {details[i]}") display(name="Larry", age=43, sex="M") ``` 本示例說明了這種情況。我們可以提供任意數量的鍵值參數。該函數將處理所有這些。 ```py $ ./details.py age: 43 name: Larry sex: M ``` ## Python 通過引用傳遞參數函數的參數通過引用傳遞。一些語言將對象的副本傳遞給函數。通過引用傳遞對象有兩個重要結論：a）與傳遞對象副本相比，此過程更快。 b）在函數中修改的可變對象將永久更改。 `passing_by_reference.py` ```py #!/usr/bin/env python # passing_by_reference.py n = [1, 2, 3, 4, 5] print("Original list:", n) def f(x): x.pop() x.pop() x.insert(0, 0) print("Inside f():", x) f(n) print("After function call:", n) ``` 在我們的示例中，我們將整數列表傳遞給函數。該對象在函數體內被修改。調用該函數（原始對象）后，將修改整數列表。 ```py def f(x): x.pop() x.pop() x.insert(0, 0) print("Inside f():", x) ``` 在函數主體中，我們使用原始對象。不帶對象的副本。在許多編程語言中，默認情況下，我們將收到對象的副本。 ```py $ ./passing_by_reference.py Original list: [1, 2, 3, 4, 5] Inside f(): [0, 1, 2, 3] After function call: [0, 1, 2, 3] ``` 一旦列表被修改，它就被永久修改了。 ## Python 全局和局部變量接下來，我們將討論如何在 Python 函數中使用變量。 `local_variable.py` ```py #!/usr/bin/env python # local_variable.py name = "Jack" def f(): name = "Robert" print("Within function", name) print("Outside function", name) f() ``` 在函數體中定義的變量具有局部范圍。它僅在函數體內有效。 ```py $ ./local_variable.py Outside function Jack Within function Robert ``` 這是示例輸出。 `global_variable.py` ```py #!/usr/bin/env python # global_variable.py name = "Jack" def f(): print("Within function", name) print("Outside function", name) f() ``` 默認情況下，我們可以在函數體內獲取全局變量的內容。 ```py $ ./global_variable.py Outside function Jack Within function Jack ``` 但是，如果要更改函數中的全局變量，則必須使用`global`關鍵字。 `global_variable2.py` ```py #!/usr/bin/env python # global_variable2.py name = "Jack" def f(): global name name = "Robert" print("Within function", name) print("Outside function", name) f() print("Outside function", name) ``` 現在，我們將在函數內部更改全局名稱變量的內容。 ```py global name name = "Robert" ``` 使用`global`關鍵字，我們引用在函數主體外部定義的變量。該變量被賦予一個新值。 ```py $ ./global_variable2.py Outside function Jack Within function Robert Outside function Robert ``` ## Python 匿名函數可以在 Python 中創建匿名函數。匿名函數沒有名稱。使用`lambda`關鍵字，幾乎無法創建任何匿名函數。 Python 程序員也將匿名函數稱為 lambda 函數。它們是 Python 中合并的函數示例的一部分。 Lambda 函數僅限于單個表達式。它們可以在可以使用常規函數的任何地方使用。 ZetCode 上有一個 [Python lambda 函數](http://zetcode.com/python/lambda/)教程。 `lambda_fun.py` ```py #!/usr/bin/env python # lambda_fun.py y = 6 z = lambda x: x * y print(z(8)) ``` 這是 lambda 函數的一個小例子。 ```py z = lambda x: x * y ``` `lambda`關鍵字創建一個匿名函數。 `x`是傳遞給 lambda 函數的參數。參數后跟一個冒號。冒號旁邊的代碼是在調用 lambda 函數時執行的表達式。 lambda 函數被分配給`z`變量。 ```py print(z(8)) ``` lambda 函數被執行。數字 8 傳遞給匿名函數，結果返回 48。請注意，`z`不是此函數的名稱。它只是分配了匿名函數的變量。 ```py $ ./lambda_fun.py 48 ``` 這是示例的輸出。 lambda 函數可以與`map()`或`filter()`函數之類的 Python 語言的其他函數部件完美地結合使用。 `lambda_fun2.py` ```py #!/usr/bin/env python # lambda_fun2.py cs = [-10, 0, 15, 30, 40] ft = map(lambda t: (9.0/5)*t + 32, cs) print(list(ft)) ``` 在示例中，我們列出了攝氏溫度。我們創建一個包含華氏溫度的新列表。 ```py ft = map(lambda t: (9.0/5)*t + 32, cs) ``` `map()`函數將匿名函數應用于`cs`列表的每個元素。它返回計算出的華氏溫度的可迭代值。 ```py $ ./lambda_fun2.py [14.0, 32.0, 59.0, 86.0, 104.0] ``` 這是示例輸出。本章是關于 Python 中的函數的。