简单的说，一个函数就是将一些语句集合在一起的部件，它们能够多次在程序中运行。函数能够计算出一个返回值，能够改变作为函数输入的参数，而这些参数每次运行时可以都不同。函数是为了代码最大程度的重用与最小化代码冗余而提供的最基本的程序结构。在程序设计中，函数最大的作用：（1）最大化代码重用与最小化代码冗余；（2）流程分解。

python中的函数

python中声明函数的关键字是 def

def func(x,f): #定义一个函数func，该函数具有两个形参x，f
    s = x*f     #函数体，计算x与f的积
    return s    #返回s的值
a = func(2,3)   #调用函数func，并传入实参2,3 （2传给x，3传给f）用a 接收函数返回值
print("2*3=%d"%a)

执行结果：
2*3=6

其实在Python中，def 是可执行的代码，python的函数是由def编写的。def是一个可执行语句—函数并不存在，直到运行到def后才有，可以在if、while的循环中嵌套。def创建了一个函数对象并将其赋值给这个函数名，函数名变成了函数的引用。

函数中的参数

# 1.位置参数和关键字参数
"""
根据调用函数实参的书写方式：
位置参数：按照实参的顺序一一给形参赋值
关键字参数：形参1=值1, 形参2=值2...
"""
def func1(a, b, c):
    print('a:', a, 'b:', b, 'c:', c)
# 位置参数
func1(10, 20, 30)
# 关键字参数
func1(c=300, a=200, b=100)

# 2.默认参数
"""
函数声明的时候可以给参数设置默认值,但是，有默认值的参数，必须放在参数列表的最后

有默认值的参数，在调用的时候可以不用传参
"""
def func2(a, c, b=0):

    print('a:', a, 'b:', b, 'c:', c)
# a=10  c=20
func2(10, 20)
# a=100 c=200 b=300
func2(100, 200, 300)


def func3(a=10, c=30, b=20):

    print('a:', a, 'b:', b, 'c:', c)

func3(a=100, b=200)
func3(100, b=200)

# 3.不定长参数
"""
参数的个数不确定的时候，可以在形参的前面加*，将这个形参变成一个元祖，用来接收多个参数，前面加**，将这个形参变成一个字典

注意：如果函数有多个参数，那么不定长参数要放在最后
"""


# 写一个函数，计算多个数的和
def my_sum(*nums):
    print(sum(nums))

my_sum()
my_sum(1)
my_sum(1, 2)
my_sum(1, 2, 3, 4)

def func4(name, age, *scores):
    print(scores, name, age)

func4('小花', 18, 90, 29, 89,a=12,c=13)

执行结果：
a: 10 b: 20 c: 30
a: 200 b: 100 c: 300
a: 10 b: 0 c: 20
a: 100 b: 300 c: 200
a: 100 b: 200 c: 30
a: 100 b: 200 c: 30
0
1
3
10
(90, 29, 89) 小花 18 {'a': 12, 'c': 13}

python中的作用域

作用域即变量的命名空间，在代码中变量名被赋值的位置决定了这个变量名能被访问到的范围。Python中的变量名在第一次赋值时已经创建，并且必须经过赋值才能使用。

x = 99
def func():
    x =88
    print("局部变量：%s"%x)
print("全局变量：%s"%x)
func()

执行结果：
全局变量：99
局部变量：88

可以使用Global 在函数中调用全局变量

x = 99
def func():
    global x #声明全局变量
    print("全局变量：%s"%x)
print("全局变量：%s"%x)
func()

执行结果：
全局变量：99
全局变量：99

在函数嵌套中可以使用nonlocal修改嵌套def作用域的名称

#不使用nonlocal
def f(x):
    n =x
    def g(y):
        x +=1  
        print(x,y)
    return g
g1 = f(2)
g1(4)

执行结果：
Traceback (most recent call last):
  File "E:/Python工程/test/1、运算符.py", line 8, in <module>
    g1(4)
  File "E:/Python工程/test/1、运算符.py", line 4, in g
    x +=1
UnboundLocalError: local variable 'x' referenced before assignment

#使用nonlocal
def f(x):
    n =x
    def g(y):
        nonlocal x
        x +=1
        print(x,y)
    return g
g1 = f(2)
g1(4)

执行结果：
3 4

工厂函数

能够记住嵌套作用域的变量值的函数。尽管那个作用域或许已经不存在了。

def f(x):
    def g(y):
        return x*y
    return g  #函数f 返回一个函数
f1 = f(2)  
print(f1)
print(f1(3))
print(f1(6))

执行结果：
<function f.<locals>.g at 0x02194228>
6
12

匿名函数

匿名函数lambda, lambda返回一个函数对象，lambda是一个表达式，不是一个语句，lambda的主体是一个单个的表达式，而不是一个代码块。
格式： lambda 参数：表达式
匿名函数的调用和普通函数一样：函数名(实参列表),也支持位置参数、关键字参数、参数设置默认值、不定长参数，匿名函数可以很方便的加入到各种容器中。

f = lambda x,y,z :x+y+z #定义一个匿名函数f ，具有三个参数
print(f(2,3,4))
l = [lambda x:x**2,
     lambda x: x ** 3,
     lambda x: x ** 4]
print(l[0](2),l[1](2),l[2](2))

执行结果：
9
4 8 16

递归函数

直接或间接的调用自身以进行循环的函数就是递归函数。它允许程序遍历拥有任意的、不可预知的形状的结构。但是递归并不是python的强项。

#递归求和
def g(n:(list,tuple)):
    if not n:
        return 0
    else:
        return n[0]+g(n[1:])

print(g([1,2,3,4,5]))

#结果：
15