Python 函数

原文： https://thepythonguru.com/python-functions/

于 2020 年 1 月 7 日更新

函数是可重用的代码段，可帮助我们组织代码的结构。 我们创建函数，以便我们可以在程序中多次运行一组语句，而无需重复自己。

创建函数

Python 使用def关键字启动函数，以下是语法：

  1. def function_name(arg1, arg2, arg3, .... argN):
  2.      #statement inside function

注意：

函数内的所有语句均应使用相等的空格缩进。 函数可以接受零个或多个括在括号中的参数（也称为参数）。 您也可以使用pass关键字来省略函数的主体，如下所示：

  1. def myfunc():
  2.     pass

让我们来看一个例子。

  1. def sum(start, end):
  2.    result = 0
  3.    for i in range(start, end + 1):
  4.        result += i
  5.    print(result)
  7. sum(10, 50)

预期输出：

  1. 1230

上面我们定义了一个名为sum()的函数，它具有两个参数start和end。 该函数计算从start到end开始的所有数字的总和。

具有返回值的函数。

上面的函数只是将结果打印到控制台，如果我们想将结果分配给变量以进行进一步处理怎么办？ 然后，我们需要使用return语句。 return语句将结果发送回调用方并退出该函数。

  1. def sum(start, end):
  2.    result = 0
  3.    for i in range(start, end + 1):
  4.        result += i
  5.    return result
  7. s = sum(10, 50)
  8. print(s)

预期输出：

  1. 1230

在这里，我们使用return语句返回数字总和并将其分配给变量s。

您也可以使用return陈述式而没有返回值。

  1. def sum(start, end):
  2.    if(start > end):
  3.        print("start should be less than end")
  4.        return    # here we are not returning any value so a special value None is returned
  5.    result = 0
  6.    for i in range(start, end + 1):
  7.        result += i
  8.    return result
  10. s = sum(110, 50)
  11. print(s)

预期输出：

  1. start should be less than end
  2. None

在 python 中，如果您未从函数显式返回值，则始终会返回特殊值None。 让我们举个例子：

  1. def test():   # test function with only one statement
  2.     i = 100
  3. print(test())

预期输出：

  1. None

如您所见，test()函数没有显式返回任何值，因此返回了None。

全局变量与局部变量

全局变量：未绑定到任何函数但可以在函数内部和外部访问的变量称为全局变量。

局部变量：在函数内部声明的变量称为局部变量。

让我们看一些例子来说明这一点。

示例 1 ：

  1. global_var = 12         # a global variable
  3. def func():
  4.     local_var = 100     # this is local variable
  5.     print(global_var)   # you can access global variables in side function
  7. func()                  # calling function func()
  9. #print(local_var)        # you can't access local_var outside the function, because as soon as function ends local_var is destroyed

预期输出：

  1. 12

示例 2：

  1. xy = 100
  3. def cool():
  4.     xy = 200     # xy inside the function is totally different from xy outside the function
  5.     print(xy)    # this will print local xy variable i.e 200
  7. cool()
  9. print(xy)        # this will print global xy variable i.e 100

预期输出：

  1. 200
  2. 100

您可以使用global关键字后跟逗号分隔的变量名称（,）在全局范围内绑定局部变量。

  1. t = 1
  3. def increment():
  4.     global t   # now t inside the function is same as t outside the function
  5.     t = t + 1
  6.     print(t) # Displays 2
  8. increment()
  9. print(t) # Displays 2

预期输出：

  1. 2
  2. 2

请注意，在全局声明变量时不能为变量赋值。

  1. t = 1
  3. def increment():
  4.     #global t = 1   # this is error
  5.     global t
  6.     t = 100        # this is okay
  7.     t = t + 1
  8.     print(t) # Displays 101
  10. increment()
  11. print(t) # Displays 101

预期输出：

  1. 101
  2. 101

实际上，无需在函数外部声明全局变量。 您可以在函数内部全局声明它们。

  1. def foo():
  2.     global x   # x is declared as global so it is available outside the function 
  3.     x = 100
  5. foo()
  6. print(x)

预期输出： 100

具有默认值的参数

要指定参数的默认值，您只需要使用赋值运算符分配一个值。

  1. def func(i, j = 100):
  2.     print(i, j)

以上函数具有两个参数i和j。 参数j的默认值为100，这意味着我们可以在调用函数时忽略j的值。

  1. func(2) # here no value is passed to j, so default value will be used

预期输出：

  1. 2 100

再次调用func()函数，但这一次为j参数提供一个值。

  1. func(2, 300) # here 300 is passed as a value of j, so default value will not be used

预期输出：

  1. 2 300

关键字参数

有两种方法可以将参数传递给方法：位置参数和关键字参数。 在上一节中，我们已经看到了位置参数的工作方式。 在本节中，我们将学习关键字参数。

关键字参数允许您使用像name=value这样的名称值对来传递每个参数。 让我们举个例子：

  1. def named_args(name, greeting):
  2.     print(greeting + " " + name )
  1. named_args(name='jim', greeting='Hello')
  3. named_args(greeting='Hello', name='jim') # you can pass arguments this way too

期望值：

  1. Hello jim
  2. Hello jim

混合位置和关键字参数

可以混合使用位置参数和关键字参数，但是对于此位置参数必须出现在任何关键字参数之前。 我们来看一个例子。

  1. def my_func(a, b, c):
  2.     print(a, b, c)

您可以通过以下方式调用上述函数。

  1. # using positional arguments only
  2. my_func(12, 13, 14)     
  4. # here first argument is passed as positional arguments while other two as keyword argument
  5. my_func(12, b=13, c=14) 
  7. # same as above
  8. my_func(12, c=13, b=14) 
  10. # this is wrong as positional argument must appear before any keyword argument 
  11. # my_func(12, b=13, 14)

预期输出：

  1. 12 13 14
  2. 12 13 14
  3. 12 14 13

从函数返回多个值

我们可以使用return语句从函数中返回多个值，方法是用逗号（,）分隔它们。 多个值作为元组返回。

  1. def bigger(a, b):
  2.     if a > b:
  3.         return a, b
  4.     else:
  5.         return b, a
  7. s = bigger(12, 100)
  8. print(s)
  9. print(type(s))

预期输出：

  1. (100, 12)
  2. <class 'tuple'>

在下一篇文章中，我们将学习 Python 循环