函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。 函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

  • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号 : 起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

image.png
Python 定义函数使用 def 关键字，一般格式如下：

  1. def 函数名（参数列表）:
  2.     函数体

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
让我们使用函数来输出”Hello World！”：

  1. #!/usr/bin/python3
  3. def hello() :
  4.     print("Hello World!")
  6. hello()

更复杂点的应用，函数中带上参数变量:
比较两个数，并返回较大的数:

  1. #!/usr/bin/python3
  3. if __name__ == '__main__':
  4.   a = 4
  5.   b = 5
  6.   print(max(a, b)) # 5
  8. def max(a, b):
  9.     if a > b:
  10.         return a
  11.     else:
  12.         return b

计算面积函数:

  1. #!/usr/bin/python3
  3. # 计算面积函数
  4. def area(width, height):
  5.     return width * height
  7. def print_welcome(name):
  8.     print("Welcome", name)
  10. print_welcome("一缕清风")
  11. w = 4
  12. h = 5
  13. print("area =", area(w, h))
  15. """ 
  16. Welcome 一缕清风
  17. area = 20 
  18. """

函数调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数：

  1. #!/usr/bin/python3
  3. # 定义函数
  4. def printme( str ):
  5.    # 打印任何传入的字符串
  6.    print (str)
  7.    return
  9. # 调用函数
  10. printme("我要调用用户自定义函数!")
  11. printme("再次调用同一函数")
  13. """ 
  14. 我要调用用户自定义函数!
  15. 再次调用同一函数 
  16. """

参数传递

在 python 中，类型属于对象，变量是没有类型的：

  1. a=[1,2,3]
  3. a="一缕清风"

以上代码中，[1,2,3] 是 List 类型，”一缕清风” 是 String 类型，
而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，String、Tuple 、Number 是不可更改的对象，而 List、Set、Dict 等则是可以修改的对象。

  • 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
  • 可变类型：变量赋值 a=[1,2,3,4] 后再赋值 a[2]=5 则是将 list a 的第三个元素值更改，本身 a 没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

  • 不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
  • 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 a 真正的传过去，修改后 fun 外部的 a 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

通过 id() 函数来查看内存地址变化：

  1. def change(a):
  2.     print(id(a))   # 4397865264 指向的是同一个对象
  3.     a=10
  4.     print(id(a))   # 4397865552 一个新对象
  6. a=1
  7. print(id(a)) # 4397865264
  8. change(a)

可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

传可变对象实例

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

  1. #!/usr/bin/python3
  3. # 可写函数说明
  4. def changeme( mylist ):
  5.    "修改传入的列表"
  6.    mylist.append([1,2,3,4])
  7.    mylist.extend([1,2,3,4])
  8.    print ("函数内取值: ", mylist)
  9.    return
  11. # 调用changeme函数
  12. mylist = [10,20,30]
  13. changeme( mylist )
  14. print ("函数外取值: ", mylist)
  16. """ 
  17. 传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
  19. 函数内取值:  [10, 20, 30, [1, 2, 3, 4], 1, 2, 3, 4]
  20. 函数外取值:  [10, 20, 30, [1, 2, 3, 4], 1, 2, 3, 4]
  21. """

参数

以下是调用函数时可使用的正式参数类型：

  • 必需参数
  • 关键字参数
  • 默认参数
  • 不定长参数

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

  1. #!/usr/bin/python3
  3. #可写函数说明
  4. def printme( str ):
  5.    print (str)
  6.    return
  8. # 调用 printme 函数，不加参数会报错
  9. printme()
  11. Traceback (most recent call last):
  12.   File "test.py", line 10, in <module>
  13.     printme()
  14. TypeError: printme() missing 1 required positional argument: 'str'

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：

  1. #!/usr/bin/python3
  3. #可写函数说明
  4. def printme(age,str):
  5.    print (str,age)
  6.    return
  8. #调用printme函数
  9. printme( 19,str = "一缕清风")
  11. """ 
  12. 一缕清风 19 
  13. """

⚠️注意: 关键字参数前面一定要后置
以下实例中演示了函数参数的使用不需要使用指定顺序：

  1. #!/usr/bin/python3
  3. #可写函数说明
  4. def printme(age,str):
  5.    print (str,age)
  6.    return
  8. #调用printme函数
  9. printme(str = "一缕清风",age=19)
  11. """ 
  12. 一缕清风 19 
  13. """

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

  1. #!/usr/bin/python3
  3. #可写函数说明
  4. def printinfo( name, age = 35 ):
  5.    print ("名字: ", name)
  6.    print ("年龄: ", age)
  7.    return
  9. #调用printinfo函数
  10. printinfo( age=50, name="一缕清风" )
  11. print ("------------------------")
  12. printinfo("一缕清风")
  14. """ 
  15. 名字:  一缕清风
  16. 年龄:  50
  17. ------------------------
  18. 名字:  一缕清风
  19. 年龄:  35 
  20. """

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

  1. def functionname([formal_args,] *var_args_tuple ):
  2.    function_suite
  3.    return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

  1. #!/usr/bin/python3
  3. # 可写函数说明
  4. def printinfo( arg1, *vartuple ):
  5.    print ("输出: ")
  6.    print (arg1)
  7.    print (vartuple)
  8.    for i in vartuple:
  9.       print (i)
  11. # 调用printinfo 函数
  12. printinfo( 70, 60, 50 )
  14. """ 
  15. 输出: 
  16. 70
  17. (60, 50)
  18. 60
  19. 50
  20. """

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

  1. #!/usr/bin/python3
  3. # 可写函数说明
  4. def printinfo( arg1, *vartuple ):
  5.    print ("输出: ")
  6.    print (arg1)
  7.    print (vartuple)
  8.    for var in vartuple:
  9.       print (var)
  10.    return
  12. # 调用printinfo 函数
  13. printinfo( 10 )
  14. printinfo( 70, 60, 50 )
  16. """ 
  17. 以上实例输出结果：
  19. 输出: 
  20. 10
  21. ()
  22. 输出: 
  23. 70
  24. (60, 50)
  25. 60
  26. 50
  27. """

加了两个星号 ** 的参数会以字典的形式导入。

  1. #!/usr/bin/python3
  3. # 可写函数说明
  4. def printinfo(arg,*args, **kwargs ):
  5.    print (arg)
  6.    print (args)
  7.    print (kwargs)
  9. # 调用printinfo 函数
  10. printinfo(1, a=2,b=3)
  13. """ 
  14. 1
  15. ()
  16. {'a': 2, 'b': 3}
  17. """

声明函数时，参数中星号 * 可以单独出现，例如:

  1. def f(a,b,*,c):
  2.     return a+b+c

如果单独出现星号 * 后的参数必须用关键字传入。

  1. >>> def f(a,b,*,c):
  2. ...     return a+b+c
  3. ... 
  4. >>> f(1,2,3)   # 报错
  5. Traceback (most recent call last):
  6.   File "<stdin>", line 1, in <module>
  7. TypeError: f() takes 2 positional arguments but 3 were given
  9. >>> f(1,2,c=3) # 正常
  10. 6
  11. >>>

匿名函数

python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

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

  1. lambda [arg1 [,arg2,.....argn]]:expression
  1. #!/usr/bin/python3
  3. # def sum(arg1,arg2):
  4. #   return arg1 - arg2
  6. # 可写函数说明
  7. sum = lambda arg1, arg2: arg1 + arg2
  9. # 调用sum函数
  10. print ("相加后的值为 : ", sum( 10, 20 ))
  11. print ("相加后的值为 : ", sum( arg1 = 20, arg2 =20 ))
  13. """ 
  14. 相加后的值为 :  30
  15. 相加后的值为 :  40 
  16. """

return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

  1. #!/usr/bin/python3
  3. # 可写函数说明
  4. def sum( arg1, arg2 ):
  5.    # 返回2个参数的和."
  6.    total = arg1 + arg2
  7.    print ("函数内 : ", total)
  8.    return total
  10. # 调用sum函数
  11. total = sum( 10, 20 )
  12. print ("函数外 : ", total)
  14. """ 
  15. 函数内 :  30
  16. 函数外 :  30 
  17. """

强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参

  1. def f(a, b, /, c, d, *, e, f):
  2.     print(a, b, c, d, e, f)

以下使用方法是正确的:

  1. def f(a, b, /, c, d, *, e, f):
  2.     print(a, b, c, d, e, f)
  4. f(10, 20, c=30, d=40, e=50, f=60)

以下使用方法会发生错误:

  1. f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
  2. f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式