原文： http://zetcode.com/lang/python/functions/

在 Python 编程教程的这一部分中，我们介绍了 Python 中的函数。

Python 函数定义

函数是用于执行特定操作的可重用代码块。 使用函数的优点是：

  • 减少代码重复
  • 将复杂的问题分解成更简单的部分
  • 提高代码的清晰度
  • 重用代码
  • 信息隐藏

Python 中的函数是一等公民。 这意味着函数与 Python 中的其他对象具有同等的状态。 可以将函数分配给变量，存储在集合中或作为参数传递。 这给语言带来了额外的灵活性。

Python 函数类型

函数有两种基本类型：内置函数和用户定义函数。 内置函数是 Python 语言的一部分； 例如dir()，len()或abs()。 用户定义的函数是使用def关键字创建的函数。

Python 创建函数

使用def关键字创建一个函数。 函数块中的语句必须缩进。

  1. def function():
  2.     pass

def关键字后跟带有圆括号和冒号的函数名称。 缩进语句形成函数的主体。

该函数稍后在需要时执行。 我们说我们调用函数。 如果我们调用一个函数，则会执行函数体内的语句。 在调用函数之前，它们不会执行。

  1. myfunc()

要调用函数，我们用圆括号指定函数名称。

ret.py

  1. #!/usr/bin/env python
  3. """
  4. The ret.py script shows how to work with
  5. functions in Python.
  6. Author: Jan Bodnar
  7. ZetCode, 2019
  8. """
  10. def show_module_name():
  12.     print(__doc__)
  14. def get_module_file():
  16.     return __file__
  18. a = show_module_name()
  19. b = get_module_file()
  21. print(a, b)

脚本顶部的字符串称为文档字符串。 它记录了当前脚本。 我们放入 Python 代码的文件称为模块。

我们定义两个函数。 第一个函数打印模块文档字符串。 第二个返回模块的路径。 函数可能会或可能不会返回值。 如果函数没有返回值，则它隐式返回None。 __doc__和__file__是特殊的状态属性。 请注意，属性的两侧都有两个下划线。

  1. $ ./ret.py
  3. The ret.py script shows how to work with
  4. functions in Python.
  5. Author: Jan Bodnar
  6. ZetCode, 2019
  8. None C:/Users/Jano/PycharmProjects/Simple/simple.py

这是程序的输出。

函数的定义必须先于其用法。 否则，口译员会抱怨NameError。

func_prec.py

  1. #!/usr/bin/env python
  3. # func_prec.py
  5. def f1():
  6.     print("f1()")
  8. f1()
  9. #f2()
  11. def f2():
  12.     print("f2()")

在上面的示例中，我们有两个函数定义。 一行被注释。 函数调用不能超出其定义。

  1. #f2()
  3. def f2():
  4.     print("f2()")

仅在定义后才能调用f2()。 取消注释该行，我们得到一个NameError。

在哪里定义函数

可以在模块，类或其他函数中定义函数。 在类内部定义的函数称为方法。

defining.py

  1. #!/usr/bin/env python
  3. # defining.py
  5. class Some():
  7.     @staticmethod
  8.     def f():
  9.         print("f() method")
  11. def f():
  12.     print("f() function")
  14. def g():
  15.     def f():
  16.         print("f() inner function")
  17.     f()
  19. Some.f()
  20. f()
  21. g()

在此示例中，我们在三个不同的位置定义了f()函数。

  1. # defining.py
  3. class Some():
  5.     @staticmethod
  6.     def f():
  7.         print("f() method")

静态方法在Some类中用装饰器定义。

  1. def f():
  2.     print("f() function")

该函数在模块中定义。

  1. def g():
  2.     def f():
  3.         print("f() inner function")
  4.     f()

此处，f()函数在另一个g()函数内部定义。 这是一个内部函数。

  1. Some.f()
  2. f()
  3. g()

通过使用方括号指定类名称，点运算符和函数名称来调用静态方法。 其他函数使用其名称和方括号来调用。

  1. $ ./defining.py
  2. f() method
  3. f() function
  4. f() inner function

这是输出。

Python 函数是对象

Python 中的函数是对象。 它们可以像 Python 中的其他对象一样进行操作。 因此，职能被称为头等公民。 在其他 OOP 语言（例如 Java 或 C# ）中，情况并非如此。

fun_obj.py

  1. #!/usr/bin/env python
  3. # fun_obj.py
  5. def f():
  6.     """This function prints a message """
  8.     print("Today it is a cloudy day")
  10. print(isinstance(f, object))
  11. print(id(f))
  13. print(f.__doc__)
  14. print(f.__name__)

在此脚本中，我们表明我们的函数也是一个对象。

  1. def f():
  2.     """This function prints a message """
  4.     print("Today it is a cloudy day")

我们定义一个f()函数。 它将消息打印到控制台。 它还具有一个文档字符串。

  1. print(isinstance(f, object))

isinstance()函数检查f()函数是否是object的实例。 Python 中的所有对象均从该基本实体继承。

  1. print(id(f))

Python 中的每个对象都有一个唯一的 ID。 id()函数返回对象的 ID。

  1. print(f.__doc__)
  2. print(f.__name__)

对象可能具有属性； 我们打印函数的两个属性：__doc__和__name__。

  1. $ ./fun_obj.py
  2. True
  3. 140353774014536
  4. This function prints a message
  5. f

这是程序的输出。

函数可以存储在集合中并传递给其他函数。

fun_coll.py

  1. #!/usr/bin/env python
  3. # fun_coll.py
  5. def f():
  6.     pass
  8. def g():
  9.     pass
  11. def h(f):
  12.     print(id(f))
  14. a = (f, g, h)
  16. for i in a:
  17.     print(i)
  19. h(f)
  20. h(g)

我们定义了三个函数。 我们将它们放在一个元组中，然后将它们传递给函数。

  1. a = (f, g, h)
  3. for i in a:
  4.     print(i)

我们将三个函数对象放在一个元组中，并使用for循环遍历它。

  1. h(f)
  2. h(g)

我们将f()和g()函数传递给h()函数。

  1. $ ./fun_coll.py
  2. <function f at 0x0000015B998E9D08>
  3. <function g at 0x0000015B998E9E18>
  4. <function h at 0x0000015B998E9840>
  5. 1492929912072
  6. 1492929912344

这是fun_coll.py程序的输出。

Python 中的三种函数

从特定的角度来看，我们可以辨别出三种函数。 始终可供使用的函数，必须导入的外部模块中包含的函数以及由程序员使用def关键字定义的函数。

three_kinds.py

  1. #!/usr/bin/env python
  3. from math import sqrt
  5. def cube(x):
  6.     return x * x * x
  8. print(abs(-1))
  9. print(cube(9))
  10. print(sqrt(81))

上面的代码中存在三种函数。

  1. from math import sqrt

sqrt()函数是从数学模块导入的。

  1. def cube(x):
  2.     return x * x * x

cube()函数是一个自定义函数。

  1. print(abs(-1))

abs()函数是易于访问的内置函数。 它是语言核心的一部分。

Python return关键字

创建一个函数来执行特定任务。 通常，这种任务会产生结果。 return关键字用于从函数返回值。 函数可能会也可能不会返回值。 如果一个函数没有return关键字，它将发送None。

returning.py

  1. #!/usr/bin/env python
  3. # returning.py
  5. def show_message(msg):
  6.     print(msg)
  8. def cube(x):
  9.     return x * x * x
  11. x = cube(3)
  12. print(x)
  14. show_message("Computation finished.")
  15. print(show_message("Ready."))

我们定义了两个函数。 一个使用return关键字，另一个则不使用。

  1. def show_message(msg):
  2.     print(msg)

show_message()函数不会显式返回值。 它在控制台上显示一条消息。

  1. def cube(x):
  2.     return x * x * x

cube()函数计算一个表达式，并使用return关键字返回其结果。

  1. x = cube(3)

在这一行中，我们称为cube()函数。 返回cube()函数的计算结果，并将其分配给x变量。 现在保存结果值。

  1. show_message("Computation finished.")

我们以消息为参数调用show_message()函数。 该消息将打印到控制台。 我们不期望此函数有值。

  1. print(show_message("Ready."))

此代码产生两行。 一种是通过show_message()函数打印的消息。 另一个是None值，该值由没有return语句的函数隐式发送。

  1. $ ./returning.py
  2. 27
  3. Computation finished.
  4. Ready.
  5. None

这是示例输出。

我们可以从函数中发送多个值。 return关键字之后的对象用逗号分隔。

returning2.py

  1. #!/usr/bin/env python
  3. # returning2.py
  5. n = [1, 2, 3, 4, 5]
  7. def stats(x):
  9.     _mx = max(x)
  10.     _mn = min(x)
  11.     _ln = len(x)
  12.     _sm = sum(x)
  14.     return _mx, _mn, _ln, _sm
  16. mx, mn, ln, sm = stats(n)
  17. print(stats(n))
  19. print(mx, mn, ln, sm)

有stats()函数的定义。 此函数返回四个值。

  1. return _mx, _mn, _ln, _sm

return关键字发回四个数字。 这些数字用逗号分隔。 实际上，我们已经发送了包含这四个值的元组。 我们也可以返回列表而不是元组。

  1. mx, mn, ln, sm = stats(n)

返回的值分配给局部变量。

  1. $ ./returning2.py
  2. (5, 1, 5, 15)
  3. 5 1 5 15

这是输出。

Python 函数重新定义

Python 本质上是动态的。 可以重新定义已经定义的函数。

redefinition.py

  1. #!/usr/bin/env python
  3. # redefinition.py
  5. from time import gmtime, strftime
  7. def show_message(msg):
  8.     print(msg)
  10. show_message("Ready.")
  12. def show_message(msg):
  13.     print(strftime("%H:%M:%S", gmtime()))
  14.     print(msg)
  16. show_message("Processing.")

我们定义一个show_message()函数。 稍后，我们提供相同函数的新定义。

  1. from time import gmtime, strftime

从时间模块中，我们导入两个函数，用于计算当前时间。

  1. def show_message(msg):
  2.     print(msg)

这是函数的第一个定义。 它仅将消息打印到控制台。

  1. def show_message(msg):
  2.     print(strftime("%H:%M:%S", gmtime()))
  3.     print(msg)

在源代码的后面，我们设置了showMessage()函数的新定义。 该消息之前带有时间戳。

  1. $ ./redefinition.py
  2. Ready.
  3. 23:49:33 Processing.

这是输出。

Python 函数参数

大多数函数接受参数。 参数是发送到函数的值。 这些函数处理这些值并有选择地返回一些值。

fahrenheit.py

  1. #!/usr/bin/env python
  3. # fahrenheit.py
  5. def C2F(c):
  6.     return c * 9/5 + 32
  8. print(C2F(100))
  9. print(C2F(0))
  10. print(C2F(30))

在我们的示例中，我们将摄氏温度转换为华氏温度。 C2F()函数接受一个参数c，即摄氏温度。

  1. $ ./fahrenheit.py
  2. 212
  3. 32
  4. 86

Python 函数中的参数可能具有隐式值。 如果未提供任何值，则使用隐式值。

fun_implicit.py

  1. #!/usr/bin/env python
  3. # fun_implicit.py
  5. def power(x, y=2):
  7.     r = 1
  9.     for i in range(y):
  10.         r = r * x
  12.     return r
  14. print(power(3))
  15. print(power(3, 3))
  16. print(power(5, 5))

在这里，我们创建了幂函数。 该函数有一个带有隐式值的参数。 我们可以使用一个或两个参数来调用该函数。

  1. $ ./fun_implicit.py
  2. 9
  3. 27
  4. 3125

Python 函数可以使用关键字指定其参数。 这意味着在调用函数时，我们同时指定了关键字和值。 当我们有多个参数并且不使用关键字而使用它们时，传递这些参数的顺序至关重要。 如果我们期望在没有关键字的函数中使用名称，年龄或性别，则无法更改其顺序。 如果使用关键字，我们可以。

fun_keywords.py

  1. #!/usr/bin/env python
  3. # fun_keywords.py
  5. def display(name, age, sex):
  7.     print("Name: ", name)
  8.     print("Age: ", age)
  9.     print("Sex: ", sex)
  11. display("Lary", 43, "M")
  12. display("Joan", 24, "F")

在此示例中，我们指定参数的顺序很重要。 否则，我们将得到错误的结果。

  1. $ ./fun_keywords.py
  2. Name:  Lary
  3. Age:  43
  4. Sex:  M
  5. Name:  Joan
  6. Age:  24
  7. Sex:  F

fun_keywords2.py

  1. #!/usr/bin/env python
  3. # fun_keywords2.py
  5. def display(name, age, sex):
  7.     print("Name: ", name)
  8.     print("Age: ", age)
  9.     print("Sex: ", sex)
  11. display(age=43, name="Lary", sex="M")
  12. display(name="Joan", age=24, sex="F")

现在我们用它们的关键字来调用函数。 可以更改顺序，尽管不建议这样做。 请注意，我们不能在关键字参数之后使用非关键字参数。 这将导致语法错误。

  1. display("Joan", sex="F", age=24)

这是法律构想。 非关键字参数后可以跟关键字参数。

  1. display(age=24, name="Joan", "F")

这将导致语法错误。 非关键字参数不能跟在关键字参数之后。

Python 中的函数可以接受任意数量的参数。

arbitrary_args.py

  1. #!/usr/bin/env python
  3. # arbitrary_args.py
  5. def do_sum(*args):
  6.     """Function returns the sum
  7. of all values"""
  9.     r = 0
  11.     for i in args:
  12.         r += i
  14.     return r
  16. print(do_sum.__doc__)
  17. print(do_sum(1, 2, 3))
  18. print(do_sum(1, 2, 3, 4, 5))

我们使用*运算符表示该函数接受任意数量的参数。 do_sum()函数返回所有参数的总和。 函数主体中的第一个字符串称为函数文档字符串。 用于记录函数。 该字符串必须用三引号引起来。

  1. $ ./arbitrary_args.py
  2. Function returns the sum
  3. of all values
  4. 6
  5. 15

我们还可以在函数中使用**构造。 在这种情况下，该函数将接受字典。 字典有任意长度。 然后，我们通常可以照常解析字典。

details.py

  1. #!/usr/bin/env python
  3. # details.py
  5. def display(**details):
  7.     for i in details:
  8.         print(f"{i}: {details[i]}")
  10. display(name="Larry", age=43, sex="M")

本示例说明了这种情况。 我们可以提供任意数量的键值参数。 该函数将处理所有这些。

  1. $ ./details.py
  2. age: 43
  3. name: Larry
  4. sex: M

Python 通过引用传递参数

函数的参数通过引用传递。 一些语言将对象的副本传递给函数。 通过引用传递对象有两个重要结论：a）与传递对象副本相比，此过程更快。 b）在函数中修改的可变对象将永久更改。

passing_by_reference.py

  1. #!/usr/bin/env python
  3. # passing_by_reference.py
  5. n = [1, 2, 3, 4, 5]
  7. print("Original list:", n)
  9. def f(x):
  11.     x.pop()
  12.     x.pop()
  13.     x.insert(0, 0)
  14.     print("Inside f():", x)
  16. f(n)
  18. print("After function call:", n)

在我们的示例中，我们将整数列表传递给函数。 该对象在函数体内被修改。 调用该函数（原始对象）后，将修改整数列表。

  1. def f(x):
  3.     x.pop()
  4.     x.pop()
  5.     x.insert(0, 0)
  6.     print("Inside f():", x)

在函数主体中，我们使用原始对象。 不带对象的副本。 在许多编程语言中，默认情况下，我们将收到对象的副本。

  1. $ ./passing_by_reference.py
  2. Original list: [1, 2, 3, 4, 5]
  3. Inside f(): [0, 1, 2, 3]
  4. After function call: [0, 1, 2, 3]

一旦列表被修改，它就被永久修改了。

Python 全局和局部变量

接下来，我们将讨论如何在 Python 函数中使用变量。

local_variable.py

  1. #!/usr/bin/env python
  3. # local_variable.py
  5. name = "Jack"
  7. def f():
  8.     name = "Robert"
  9.     print("Within function", name)
  11. print("Outside function", name)
  12. f()

在函数体中定义的变量具有局部范围。 它仅在函数体内有效。

  1. $ ./local_variable.py
  2. Outside function Jack
  3. Within function Robert

这是示例输出。

global_variable.py

  1. #!/usr/bin/env python
  3. # global_variable.py
  5. name = "Jack"
  7. def f():
  8.     print("Within function", name)
  10. print("Outside function", name)
  11. f()

默认情况下，我们可以在函数体内获取全局变量的内容。

  1. $ ./global_variable.py
  2. Outside function Jack
  3. Within function Jack

但是，如果要更改函数中的全局变量，则必须使用global关键字。

global_variable2.py

  1. #!/usr/bin/env python
  3. # global_variable2.py
  5. name = "Jack"
  7. def f():
  9.     global name
  10.     name = "Robert"
  11.     print("Within function", name)
  13. print("Outside function", name)
  14. f()
  15. print("Outside function", name)

现在，我们将在函数内部更改全局名称变量的内容。

  1. global name
  2. name = "Robert"

使用global关键字，我们引用在函数主体外部定义的变量。 该变量被赋予一个新值。

  1. $ ./global_variable2.py
  2. Outside function Jack
  3. Within function Robert
  4. Outside function Robert

Python 匿名函数

可以在 Python 中创建匿名函数。 匿名函数没有名称。 使用lambda关键字，几乎无法创建任何匿名函数。 Python 程序员也将匿名函数称为 lambda 函数。 它们是 Python 中合并的函数示例的一部分。

Lambda 函数仅限于单个表达式。 它们可以在可以使用常规函数的任何地方使用。 ZetCode 上有一个 Python lambda 函数教程。

lambda_fun.py

  1. #!/usr/bin/env python
  3. # lambda_fun.py
  5. y = 6
  7. z = lambda x: x * y
  8. print(z(8))

这是 lambda 函数的一个小例子。

  1. z = lambda x: x * y

lambda关键字创建一个匿名函数。 x是传递给 lambda 函数的参数。 参数后跟一个冒号。 冒号旁边的代码是在调用 lambda 函数时执行的表达式。 lambda 函数被分配给z变量。

  1. print(z(8))

lambda 函数被执行。 数字 8 传递给匿名函数，结果返回 48。 请注意，z不是此函数的名称。 它只是分配了匿名函数的变量。

  1. $ ./lambda_fun.py
  2. 48

这是示例的输出。

lambda 函数可以与map()或filter()函数之类的 Python 语言的其他函数部件完美地结合使用。

lambda_fun2.py

  1. #!/usr/bin/env python
  3. # lambda_fun2.py
  5. cs = [-10, 0, 15, 30, 40]
  7. ft = map(lambda t: (9.0/5)*t + 32, cs)
  8. print(list(ft))

在示例中，我们列出了摄氏温度。 我们创建一个包含华氏温度的新列表。

  1. ft = map(lambda t: (9.0/5)*t + 32, cs)

map()函数将匿名函数应用于cs列表的每个元素。 它返回计算出的华氏温度的可迭代值。

  1. $ ./lambda_fun2.py
  2. [14.0, 32.0, 59.0, 86.0, 104.0]

这是示例输出。

本章是关于 Python 中的函数的。