当某些任务（例如求一个数的阶乘）需要在一个程序中的不同位置重复执行时，会造成代码的重复率高，应用程序代码繁琐，解决这个问题的方法就是使用函数，无论是在哪门编程语言中，函数（在类中称为方法，意义是相同的）都扮演着至关重要的角色，模块是python的代码组织单元，它将函数，类，和数据封装起来以便重用，模块往往对应python的程序文件，Python标准库和第三方提供了大量的模块。
1.0 函数的定义
在Python，函数定义的基本形式如下：
def 函数名(函数参数):
函数体
return 表达式或者值
在这里说明几点：
- 在Python中采用def关键字进行函数的定义，不用指定返回值的类型。
- 函数参数可以是零个，一个或者多个，同样，函数参数也不用指定参数类型，因为在Python中变量都是弱类型的，Python会自动根据值来维护其类型。
- 在Python中，函数定义中的缩进部分是函数体
- 函数的返回值是通过函数中的return语句中获得的，return语句是可选的，它可以在函数体内的任何地方，表现函数调用执行到此结束，如果没有return语句，会自动返回None（空值），如果有return 语句，但是return后面没有接表达式或者值，也是返回None(空值)
下列定义3个函数
def PrintHello():
print("Hello,world!")
def PrintNum():
for i in range(10):
print(i)
def Add(a,b):
return a+b
PrintHello()
PrintNum()
print(Add(1,2))
2.0 Python函数参数传递
- 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
- 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响。
Python不可变类型参数
def printtime(a):
a = 10
print(a)
b = 2
printtime(b)
print(b)
运行结果：
10
2
Python可变类型参数
def printtime( list1):
list1.append([1,2,3])
print(list1)
mylist = [10,20,30]
printtime(mylist)
print(mylist)
运行结果：
[10, 20, 30, [1, 2, 3]]
[10, 20, 30, [1, 2, 3]]
3.0 Python 函数的参数类型
- 必须参数
- 默认参数
- 可变参数
- 关键字参数
- 组合参数
下列给大家逐一举例：
3.1 必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：
def printme(str):
print(str)
return
printme()
运行结果：
Traceback (most recent call last):
File "E:/pycharm专业版代码路径/身份.py", line 12, in <module>
printme()
TypeError: printme() missing 1 required positional argument: 'str'
3.2 关键字函数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
def printme(str):
print(str)
return
printme(str="假书生@")
运行结果：
假书生@
3.3 默认函数
def printinfo(name, age=35):
"打印任何传入的字符串"
print("名字: ", name)
print("年龄: ", age)
return
# 调用printinfo函数
printinfo(age=50, name="runoob")
print("------------------------")
printinfo(name="runoob")
运行结果：
名字: runoob
年龄: 50
------------------------
名字: runoob
年龄: 35
3.4 不定长函数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
示例如下：
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
运行结果：
输出:
70
(60, 50)
- 如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return
运行结果;
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return
- 还有一种就是参数带两个星号 **基本语法如下：
def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]
加了两个星号 ** 的参数会以字典的形式导入。
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
运行结果：
输出:
1
{'a': 2, 'b': 3}
声明函数时，星号可以单独出现，例如：
def f(a,b,*,c):
return a+b+c
如果单独出现星号，后面的参数需要以关键字引入：
>>> def f(a,b,*,c):
... return a+b+c
...
>>> f(1,2,3) # 报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
3.5 匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
- lambda只是一个表达式，函数体比def简单很多。
- lambda函数拥有自己的命名空间，而不能访问自己参数列表之外或全局明敏空间里的参数。
语法：
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
示例如下：
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
运行结果：
相加后的值为 : 30
相加后的值为 : 40
return语句
return[表达式]语句用于退出函数，选择性的向调用方法返回一个表达式，不带参数值的return语句返回None,之前的例子都没有示范如何返回数值，以下实例演示了return语句的用法：
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)
运行实例：
函数内 : 30
函数外 : 30
3.6 强制位置参数
Python3.8新增了一个函数形参语法/用来知名参数形参必须使用指定位置参数，不能使用关键字的形式。在以下的例子中，形参a和b必须使用指定位置参数，c或d可以是位置形参或关键字形参，而e或f要求为关键字形参：
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
以下使用方法是正确的:
f(10, 20, 30, d=40, e=50, f=60)
以下使用方法会发生错误：
f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式
3.7 组合函数
组合参数就是将之前讲过的4中参数同时引入函数作为形参，值得注意的是，定义参数时的顺序必须为：必须参数、关键字参数、默认参数、不定长参数。
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
f1(1, 2, 3, 'a', 'b', x=86)
输出：
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 86}
3.8 闭包函数
在python中，闭包(closure)指函数的嵌套，用户可以在函数内部定义一个嵌套函数，将嵌套函数视为一个对象，所以可以将嵌套函数作为定义他的函数的返回结果，
def func_lib():
def add(x,y):
return a+b
return add
fadd = func_lib()
print(fadd(1,2))
在函数func_lib()中定义了一个嵌套函数add(x,y),并作为函数func_lib()的返回值
4.0 函数的递归调用
函数在执行的过程中直接或间接调用本身，称为递归调用，Python语言允许递归调用。
def f(x):
if x == 1:
return 1
else:
return(f(x-1)+x*x)
print(f(5))
