(19)Python函数

可以定义提供所需函数的功能。 以下是在Python中定义函数的简单规则。

• 函数块以关键字def开头，后跟函数名和小括号(())。
• 任何输入参数或参数应放置在这些小括号中。也可以在这些小括号内定义参数。
• 每个函数中的代码块以冒号(:)开始，并缩进。
• 函数内的第一个语句可以是可选语句 – 函数的文档或docstring字符串。
• 语句return [expression]用于退出一个函数，可选地将一个表达式传回给调用者。如果没有使用参数的return语句，则它与return None相同。

语法

def functionname( parameters ):
    "function_docstring"
    function_suite
    return [expression]
Python

默认情况下，参数具有位置行为，您需要按照定义的顺序通知它们或调用它们。

示例

以下函数将字符串作为输入参数，并在标准屏幕上打印参数的值。

def printme( str ):
    "This prints a passed string into this function"
    print (str)
    return
Python

定义一个函数需要为它起一个名字，指定要包括在函数中的参数并构造代码块。
当函数的基本结构完成，可以通过从另一个函数调用它或直接从Python提示符执行它。 以下是一个调用print_str()函数的例子 –

#!/usr/bin/python3

# Function definition is here
def print_str( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call print_str function
print_str("This is first call to the user defined function!")
print_str("Again second call to the same function")
Python

当执行上述代码时，会产生以下结果 –

This is first call to the user defined function!
Again second call to the same function
Shell

Python语言中的所有参数(参数)都将通过引用传递。如果在函数中更改参数所指的内容，则更改也会反映在调用函数的外部。 例如 –

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)
   mylist[2]=50
   print ("Values inside the function after change: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
Python

在这里，将保持对传递对象的引用并在相同的对象中赋值。 因此，这将产生以下结果 –

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]
Shell

在上面的输出结果中，可以清楚地看到，mylist[2]的值原来只在函数内赋了一个值：50，但在函数外部的最后一个语句打出来的值是：50，这说明更改也会反映在调用函数的外部。

还有一个例子：参数通过引用传递，引用在被调用函数内被覆盖。

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def changeme( mylist ):
    "This changes a passed list into this function"
    mylist = [1,2,3,4] # This would assi new reference in mylist
    print ("Values inside the function: ", mylist)
    return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
Python

参数mylist是changeme()函数的局部变量。在函数中更改mylist不影响mylist的值。函数执行完成后，最终将产生以下结果 –

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]
Python

可以使用以下类型的形式参数来调用函数 –

• 必需参数
• 关键字参数
• 默认参数
• 可变长度参数

必需参数是以正确的位置顺序传递给函数的参数。这里，函数调用中的参数数量应与函数定义完全一致。

如下示例中，要调用printme()函数，则必需要传递一个参数，否则会出现如下语法错误 –

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# 现在要调用函数，但不提供参数
printme()
Python

当执行上述代码时，会产生以下结果 –

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)
Python

提示：在调用 printme()函数时，提供一个参数就可以了。如：printme('Maxsu') 。

关键字参数与函数调用有关。 在函数调用中使用关键字参数时，调用者通过参数名称来标识参数。

这允许跳过参数或将其置于无序状态，因为Python解释器能够使用提供的关键字将值与参数进行匹配。还可以通过以下方式对printme()函数进行关键字调用 –

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme( str = "My string")
Python

当执行上述代码时，会产生以下结果 –

My string
Python

以下示例给出了更清晰的映射。请注意，参数的顺序并不重要。

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print ("Name: ", name, "Age: ", age)
   return

# Now you can call printinfo function
printinfo( age = 25, name = "Maxsu" )
printinfo(name = "Minsu", age = 26 )
Shell

当执行上述代码时，会产生以下结果 –

Name:  Maxsu Age:  25
Name:  Minsu Age:  26
Shell

如果在该参数的函数调用中没有提供值，则默认参数是一个假设为默认值的参数。 以下示例给出了默认参数的想法，如果未通过，则打印默认年龄(age) –

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printinfo( name, age = 25 ):
   "This prints a passed info into this function"
   print ("Name: ", name, "Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 22, name = "Maxsu" )
printinfo( name = "Minsu" )
Python

当执行上述代码时，会产生以下结果 –

Name:  Maxsu Age  22
Name:  Minsu Age  25
Shell

在定义函数时，可能需要处理更多参数的函数。这些参数被称为可变长度参数，并且不像要求的和默认的参数那样在函数定义中命名。

具有非关键字变量参数的函数的语法如下：

def functionname([formal_args,] *var_args_tuple ):
    "function_docstring"
    function_suite
    return [expression]
Python

星号(*)放在保存所有非关键字变量参数值的变量名之前。 如果在函数调用期间没有指定额外的参数，则此元组保持为空。以下是一个简单的例子 –

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printinfo( arg1, *vartuple ):
    "This prints a variable passed arguments"
    print ("Output is: ", arg1)
    for var in vartuple:
      print (var, )
    return

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )
Python

当执行上述代码时，会产生以下结果 –

Output is:  10
Output is:  70
60
50
Shell

这些函数被称为匿名的，因为它们没有使用def关键字以标准方式声明。可以使用lambda关键字创建小型匿名函数。

• Lambda表单可以接受任意数量的参数，但只能以表达式的形式返回一个值。它们不能包含命令或多个表达式。
• 匿名函数不能直接调用打印，因为lambda需要一个表达式。
• Lambda函数有自己的本地命名空间，不能访问其参数列表和全局命名空间中的变量。
• 虽然lambdas是一个单行版本的函数，但它们并不等同于C或C++中的内联语句，其目的是通过传递函数来进行堆栈分配。

语法

lambda函数的语法只包含一个语句，如下所示：

lambda [arg1 [,arg2,.....argn]]:expression
Python

以下是一个示例，以显示lambda形式的函数如何工作 –

#!/usr/bin/python3

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2


# Now you can call sum as a function
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))
Python

当执行上述代码时，会产生以下结果 –

Value of total :  30
Value of total :  40
Python

return [expression]语句退出一个函数，可选地将一个表达式传回给调用者。没有参数的return语句与return None相同。

下面给出的所有例子都没有返回任何值。可以从函数返回值，如下所示：

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print ("Inside the function : ", total)
   return total

# Now you can call sum function
total = sum( 10, 20 )
print ("Outside the function : ", total )
Python

全部执行上述代码时，会产生以下结果 –

Inside the function :  30
Outside the function :  30
Shell

程序中的所有变量在该程序的所有位置可能无法访问。这取决于在哪里声明一个变量。变量的范围决定了可以访问特定标识符的程序部分。Python中有两个变量的基本范围 –

• 全局变量
• 局部变量

在函数体内定义的变量具有局部作用域，外部定义的变量具有全局作用域。

局部变量只能在它们声明的函数内部访问，而全局变量可以通过所有函数在整个程序体中访问。 当调用一个函数时，它内部声明的变量被带入范围。 以下是一个简单的例子 –

total = 0 # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print ("Inside the function local total : ", total)
   return total

# Now you can call sum function
sum( 10, 20 )
print ("Outside the function global total : ", total )
Python

当执行上述代码时，会产生以下结果 –

Inside the function local total :  30
Outside the function global total :  0
Python