Python 3 – 函数

函数是一块有组织、可重复使用的代码，用于执行单个、相关的操作。函数为您的应用程序提供了更好的模块化和高度重用的代码。

如您所知，Python给您提供了许多内置函数，如print()等，但您也可以创建自己的函数。这些函数称为 用户定义的函数。

定义函数

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

• 函数块以关键字 def 开始，后跟函数名称和括号 (())。

• 任何输入参数或参数都应放置在括号内。您也可以在这些括号内定义参数。

• 函数的第一条语句可以是可选语句——函数的文档字符串或 文档注释。

• 每个函数中的代码块以冒号 (:) 开始，并进行缩进。

• 声明 return [expression] 退出函数，可选择向调用者传回一个表达式。没有参数的返回语句与 return None 相同。

语法

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

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

示例

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

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

调用函数

定义函数给它命名，指定要包含在函数中的参数，并构造代码块。

完成了函数的基本结构后，您可以通过从另一个函数或直接从Python提示符中调用它来执行它。以下是调用 printme () 函数的示例−

#!/usr/bin/python3

# 在此处定义函数
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

#现在您可以调用printme函数
printme("这是对用户定义函数的第一次调用！")
printme("再次调用相同的函数")

运行上述代码时，它将产生以下结果−

这是对用户定义函数的第一次调用！
再次调用相同的函数

传递引用 vs 值

Python语言中的所有参数（参数）均按引用传递。这意味着如果您更改函数内部参数所引用的内容，则更改也会反映在调用函数中。例如−

#!/usr/bin/python3

# 在此处定义函数
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("change之前函数内部的值: ", mylist)

   mylist[2]=50
   print ("change之后函数内部的值: ", mylist)
   return

#现在您可以调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外的值: ", mylist)

在这里，我们保留了传递对象的引用，并在同一对象中添加值。因此，这将产生以下结果−

函数内部更改前的值：[10，20，30]
函数内部更改后的值：[10，20，50]
函数外部的值：[10，20，50]

还有一个例子，其中参数通过引用传递，并且引用被重新分配在被调用的函数内部。

#!/usr/bin/python3

# 函数定义在这里
def changeme ( mylist）：
   “这将把传递的列表更改为此函数”
   mylist = [1,2,3,4]＃这将在mylist中分配新引用
   print(“函数内的值：”，mylist)
   返回

#现在可以调用changeme函数
mylist = [10,20,30]
changeme(mylist)
print(“函数外的值：”，mylist)

参数 mylist 是函数changeme本地的。在函数内更改mylist不会影响mylist。该函数没有任何效果，最终会产生以下结果−

函数内的值：[1, 2, 3, 4]
函数外的值：[10, 20, 30]

函数参数

可以使用以下类型的正式参数调用函数−

• 请求参数
• 关键字参数
• 默认参数
• 可变长度参数

请求参数

请求参数是按正确的位置顺序传递给函数的参数。在这里，函数调用中的参数数量应与函数定义完全匹配。

要调用函数 printme() ，您肯定需要传递一个参数，否则它会产生语法错误，如下所示−

#!/usr/bin/python3

# 函数定义在这里
def printme(str）：
   “这会将传递的字符串打印到此函数中”
   print (str)
   返回

#现在可以调用printme函数
printme()

执行上述代码时，将产生以下结果−

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

关键字参数

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

这允许您跳过参数或将它们放置在不同的顺序中，因为Python解释器能够使用提供的关键字将值与参数匹配。您还可以通过以下方式对 printme() 函数进行关键字调用−

#!/usr/bin/python3

# 函数定义在这里
def printme(str）：
   “这将把传递的字符串打印到此函数中”
   print (str)
   返回

#现在可以调用printme函数
printme(str = “My string”)

执行上述代码时，将产生以下结果−

My string

以下示例提供了更清晰的图像。请注意，参数的顺序没有关系。

#!/usr/bin/python3

# 函数定义在这里
def printinfo(name,age）：
   “这将在此函数中传递的信息打印出来”
   print (“姓名：”，name)
   print （“年龄”，年龄）
   返回

#现在可以调用printinfo函数
printinfo(年龄=50，姓名=“米凯”）

执行上述代码时，将产生以下结果−

姓名：miki
年龄：50

默认参数

默认参数是指在函数调用时，如果没有为该参数提供值，则假定该参数具有默认值。以下示例给出了默认参数的概念，如果未传递年龄，则打印默认的年龄：

#!/usr/bin/python3

# 函数定义在这里
def printinfo(name，age=35):
    “将传递的信息打印到此函数中”
    print（“姓名：”，name）
    print（“年龄”，age）
    回报

#现在您可以调用printinfo函数
printinfo(age=50，name="miki")
printinfo(name="miki")

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

姓名：miki
年龄：50
姓名：miki
年龄：35

可变长度参数

在定义该函数时，您可能需要为更多的参数处理该函数。这些参数称为变量长度参数，并且与所需和默认参数不同，在函数定义中没有命名。

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

def functionname(max_args，*var_args_tuple):
    “function_docstring”
    function_suite
    return [expression]

在保存所有非关键字变量参数的值的变量名之前放置一个星号（*）。如果在函数调用期间未指定其他参数，则该元组保持为空。以下是一个简单的示例-：

#!/usr/bin/python3

# 函数定义在这里
def printinfo(arg1，*vartuple):
    “这会打印一个可变的传递参数”
    print（“输出是：”）
    print（arg1）

    for var in vartuple：
      print（var）
    回报

#现在您可以调用printinfo函数
printinfo(10)
printinfo(70,60,50)

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

输出是：
10
输出是：
70
60
50

匿名函数

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

• Lambda形式可以采用任意数量的参数，但只返回一个表达式形式的值。它们不能包含命令或多个表达式。

• 匿名函数不能直接调用打印，因为Lambda需要表达式。

• lambda函数具有自己的本地命名空间，不能访问除参数列表中的变量和全局命名空间中的变量以外的变量。

• 虽然看起来lambda是C或C ++中内联语句的一行版本，但它们与在调用期间通过传递函数进行堆栈分配的目的不同，用于性能原因。

语法

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

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

以下是一个示例，演示了 lambda 函数形式的工作原理：

#!/usr/bin/python3

# 函数定义在这里
sum = lambda arg1，arg2: arg1 + arg2

#现在您可以将sum作为函数调用
print（“总值：”，sum（10,20））
print（“总值：”，sum（20,20））

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

Value of total :  30
Value of total :  40

返回语句

return [expression]语句退出一个函数，并可向调用者返回表达式。没有参数的返回语句与return None相同。

下面的所有示例都不返回任何值。您可以按以下方式从函数中返回值 –

#!/usr/bin/python3

# 在这里定义函数
def sum( arg1, arg2 ):
   # 将参数相加并返回它们。
   total = arg1 + arg2
   print ("Inside the function : ", total)
   return total

# 您现在可以调用sum函数
total = sum( 10, 20 )
print ("Outside the function : ", total )

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

Inside the function :  30
Outside the function :  30

变量的作用域

程序中的所有变量可能无法在程序的所有位置都可访问。这取决于您在哪里声明变量。

变量的作用域确定了您可以访问特定标识符的程序部分。Python中有两个基本的变量作用域 –

• 全局变量
• 局部变量

全局变量与局部变量

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

这意味着局部变量只能在声明它的函数内部访问，而全局变量可以被程序体内的所有函数访问。当您调用函数时，其中声明的变量被引入到作用域中。以下是一个简单的示例 –

#!/usr/bin/python3

total = 0   # 这是全局变量。
# 在这里定义函数
def sum( arg1, arg2 ):
   # 将参数相加并返回它们。
   total = arg1 + arg2; # 这里total是局部变量。
   print ("Inside the function local total : ", total)
   return total

# 您现在可以调用sum函数
sum( 10, 20 )
print ("Outside the function global total : ", total )

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

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