11.1、函数：

函数即变量

函数的作用域只跟函数声明时定义的作用域有关，跟函数的调用位置无任何关系

1、函数格式：

def test(x):

'''

2*x+1

:param x:整形数字

:return: 返回计算结果

'''

y = 2 * x + 1

return y

a = test()

#调用函数

print(a)

11.2、函数返回：

1、规则：

（1）函数的返回值可以是任何数据类型

（2）函数如果有多个返回值用逗号隔开

（3）函数只用一个返回值时，返回值的数据类型不发生改变

（4）函数有多个返回值时，返回值以元组的形式返回

（5）函数遇到return时函数结束

2、用法：

def test01():

msg = 'test01'

return msg

#函数返回一个值

def test02():

msg = 'test02'

return 1, 2, 3, 4, 'a', ['alex'], {'name': 'alex'}, None

#函数返回多个值

t1 = test01()

t2 = test02()

print(t1)

print(t2)

11.3、函数普通传参：

1、规则：

（1）函数分为形参和实参，形参在函数被调用后释放

（2）位置参数，必须一一对应，缺一不行多一也不行

（3）关键字参数，无须一一对应，缺一不行多一也不行

（4）两者混用时，位置参数必须在关键字参数左边

（5）默认参数在不传入实参时使用默认值，在传入实参时默认参数值被覆盖

（6）一个参数不能传多个值

2、用法：

（1）位置参数：

def test(x, y, z):

print(x)

print(y)

print(z)

test(1, 2, 3)

（2）关键字参数：

def test(x, y, z):

print(x)

print(y)

print(z)

test(y=1, x=3, z=4)

（3）位置参数和关键字参数混用：

def test(x, y, z):

print(x)

print(y)

print(z)

test(1, y=2, 3)

#报错

test(1, 3, y=2)

#报错

test(1, 3, z=2, y=4)

#报错

test(z=2, 1, 3)

#报错

test(1, 3, z=2)

（4）默认参数：

def handle(x, type='mysql'):

print(x)

print(type)

handle('hello')

handle('hello', type='sqlite')

11.4、参数组：

1、规则：

（1）列表参数：

实参的数据类型除字典外都可以

可以传入多个实参

实参可以重复

传入的实参以元组的形式存储，不传入实参是空元组

传入的列表格式为*[1,2,3,4]，传入元组的格式为*(5,6,7,8)

（2）字典参数：

实参的数据类型只能是字典

可以传入多个实参

实参的key值不可以重复

传入的实参以字典的形式存储，不传入实参是空字典

传入字典的格式为**{1:2,3:4}(key必须是字符串型)或 y=2, z=3；

（3）列表参数和字典参数在一起使用：

可以传递任何的参数

2、用法：

（1）参数组之列表参数(*args)：

def test(x, *args):

print(x)

print(args)

test(1)

test(1, *['x', 'y', 'z'],*('x', 'y', 'z'),1,2,3,3,4,5)

（2）参数组之字典参数(**kwargs)：

def test(x, **kwargs):

print(x)

print(kwargs)

test(1)

test(1,**{"a":5,"b":6},y=2, z=3)

（3）列表参数和字典参数混用：

def test(x, *args, **kwargs):

print(x)

print(args, args[-1])

print(kwargs, kwargs.get('y'))

test(1, *['x', 'y', 'z'],*('x', 'y', 'z'),1,2,3,3,4,5,**{"a":5,"b":6},y=2, z=3)

#输出结果：

#1

#('x', 'y', 'z', 'x', 'y', 'z', 1, 2, 3, 3, 4, 5) 5

#{'a': 5, 'b': 6, 'y': 2, 'z': 3} 2

11.5、函数局部变量和全局变量：

1、规则：

（1）函数的内容无global关键字：

1）有声明局部变量：

优先读取局部变量，能读取全局变量，无法对全局变量重新赋值

2）无声明局部变量：

能读取全局变量，无法对全局变量重新赋值

（2）函数的内容有global关键字：

1）有声明局部变量：

局部变量本质上就是全局的那个变量，全局变量可读取可赋值

2）无声明局部变量：

全局变量可读取可赋值

（3）nonlocal：

nonlocal代表指定上一级变量，如果没有就继续往上直到找到为止，上一级只能是局部变量，

如果是全局变量会报错；

（4）变量书写规范：

全局变量的变量名大写，局部变量的变量名小写

global和nonlocal声明必须写在函数的最上面

2、用法：

name = "test01"

def lc():

global name

name = "test02"

name1 = "test04"

def lc1():

nonlocal name1

name1 = "test03"

lc1()

print(name1)

print(name)

lc()

print(name)

# 输出值为：test01、test03、test02

11.6、函数的向前引进：

1、规则：

（1）函数即变量，调用时生效，不调用不生效

（2）python是按照顺序依次从上往下执行的，函数都是加载到内存当中的，

只要在所有的函数之后调用函数都能够调用到；

2、用法：

（1）

def bar():

print('from bar')

def foo():

print('from foo')

bar()

foo()

（2）

def foo():

print('from foo')

bar()

def bar():

print('from bar')

foo()

11.7、函数的递归：

1、规则：

（1）递归函数意在减小问题的规模

（2）递归函数是一层一层的调用自己，在得到结果后再一层层的将结果进行返回

（3）递归函数效率不高

2、用法：

def calc(n):

if int(n / 2) == 0:

return n

res = calc(int(n / 2))

return res

print(calc(5))

#示意图：

11.8、匿名函数：

1、匿名函数的格式：

func=lambda x:x+1

# x表示输入的变量，x+1表示return x+1

print(func(10))

上面的匿名函数等价于如下函数：

def func(x):

return x+1

print(func(10))

2、说明：

（1）匿名函数只能用于简单的逻辑计算；

（2）匿名函数常与其他函数一同使用；

11.9、高阶函数：

1、高阶函数定义:

（1）函数接收的参数是一个函数名

（2）函数的返回值是一个函数名

（3）满足上述条件任意一个,都可称之为高阶函数

2、示例：

（1）把函数当作参数传给另外一个函数：

def foo(n):

print(n)

def bar(name):

print('my name is %s' %name)

foo(bar('lc'))

"""

输出结果：

my name is lc

None #因为函数没有返回值，所以print(n)时打印出了None

"""

（2）返回值中包含函数：

def bar():

print('from bar')

def foo():

print('from foo')

return bar

foo()()

"""

输出结果：

from foo

from bar

"""