函数

1 创建函数与调用

def py(): //创建函数
    print("人生苦短，我用python")
py() //调用函数
结果
人生苦短，我用python

1.1 lambda函数

python允许使用lambda关键字创建匿名函数。
lambda x,y : x * y
：左边是函数的参数，多个参数用逗号隔开。
：右边是返回值。
lambda语句会返回一个函数对象，使用前，赋值即可。

a = lambda x,y : x * y
print(a(4,5))
结果
20

1.2 函数文档

所谓函数文档，其实就是给函数写注释

def py():
    """
    使用python  // '''也可以
    """
    print("人生苦短，我用python")
help(py)
结果
py()
    使用python

2 函数参数

函数的括号内就是函数参数，多个参数用逗号隔开。

2.1 形参和实参

• 形参（parameter）：创建函数时小括号里的参数
• 实参（argument）：函数被调用过程中传递进来的参数

2.2 关键字参数

函数中有多个参数时，默认为顺序匹配，为防止搞乱参数位置，可以在函数调用的时候设置关键字参数，以避免此种情况的发生。
关键字参数其实就是在传入实参时指定形参的变量名

def test(name,thing):
    print(name+'有'+thing)
test('无限手套','灭霸')
test(name='斯达克',thing='钢铁侠战衣')//这里采用了关键字参数
结果：
无限手套有灭霸
斯达克有钢铁侠战衣

2.3 默认参数

默认参数是在参数定义的过程中，为形参赋初值。当函数调用的时候，不传递实参，则默认使用形参的初始值代替。

def test(name='斯达克',thing='钢铁侠战衣'): //name和thing是默认参数
    print(name+'有'+thing)
test()
结果：
斯达克有钢铁侠战衣

2.4 收集参数

收集参数也叫可变参数。当不清楚函数有多少个参数时可以使用，在参数前加上*即可。

def test(*listx):
    print(listx)
test(1,2,3,4,5,'avengers')
结果：
(1, 2, 3, 4, 5, 'avengers')

当收集参数后，还有其它参数时，在调用函数时需用关键字参数来指定

def test(*hero,name):
    print(*hero,'属于',name)
test('蜘蛛侠','黑豹','毒液',name='avengers') //使用关键字参数指定了name
结果：
蜘蛛侠 黑豹 毒液 属于 avengers

2.4.1 解包

要将元组或列表传入收集参数，调用函数时，要在实参前加上*，表示实参需要解包后使用。

def test(*hero):
    print(len(hero))
    print(hero)
name =['蜘蛛侠','黑豹','毒液']
test(name)
test(*name)
结果：
1
(['蜘蛛侠', '黑豹', '毒液'],)
3
('蜘蛛侠', '黑豹', '毒液')

2.5 函数返回值

return关键字用于返回函数的值，print是打印值不是返回值。不写renturn，python函数默认返回None。pyhton函数都是有返回值的。

def test():
    print('avengers')
print(test()) //print打印函数的返回值，此时返回值为None
结果：
avengers
None

2.6 变量作用域

局部变量（local variable）
全局变量（global variable）

def discounts(price,rate):
    new_price =  price * rate
    print('打折后的价格为：',new_price)

old_price = float(input('请输入原价： '))
rate2 = float(input('请输入折扣： '))
discounts(old_price,rate2)
结果：
请输入原价： 100
请输入折扣： 0.5
打折后的价格为： 50.0

如上程序：

• 函数内的参数price，rate和new_price属于局部变量。
• old_price、rate2属于全局变量。

函数里定义的参数和变量都是局部变量，出了函数后这些变量都是无效的。
原理：python在运行函数时，利用栈进行存储，函数执行完毕，函数内的数据都自动被删除。所以函数外无法访问函数内的局部变量。
全局变量都是在函数外部定义的，全局变量拥有更大的作用域，函数内也可以访问。

2.7 global关键字

# 尝试在函数内部修改全局变量的值
def test():
    num = 10
    print("修改变量后的值为：",num)
num = 100
test()
print("全局变量num的值为：",num)
结果：
修改变量后的值为： 10
全局变量num的值为： 100

在函数内部修改全局变量的值，python会创建一个名字与全局变量相同的局部变量以代替，所以全局变量的值不会被改变。

如果想要在函数内部修改全局变量就要使用global关键字。

def test():
    global num //说明num为全局变量
    num = 10
    print("修改变量后的值为：",num)
num = 100
print("函数调用前num的值为：",num)
test()
print("执行函数后num的值为：",num)
结果：
函数调用前num的值为： 100
修改变量后的值为： 10
执行函数后num的值为： 10

2.8 内嵌函数

所谓内嵌函数即函数内部再定义函数

def fun1():
    print("这是函数1")
    def fun2():
        print("这是函数2")
    fun2()
fun1()
结果：
这是函数1
这是函数2

2.9 闭包

内嵌函数引用了外部作用域的变量（非全局变量），该内嵌函数则为闭包

def h1(x):
    def h2(y):
        return x * y
    return h2
print(h1(2)(3)) //2赋值给了h1,3赋值给了h2
结果：
6

以下函数h2不是闭包，因为引用了全局变量num

def h1(x):
    def h2(y):
        return x * y * num
    return h2
num = 4
print(h1(2)(3))
结果：
24

闭包只能引用外部函数的变量，如果修改就会报错。

def h1(x):
    def h2():
        x *= x
        return x 
    return h2
print(h1(2)())
结果：
UnboundLocalError: local variable 'x' referenced before assignment

2.9.1 nonlocal关键字

闭包修改外部函数的变量，需要使用nonlocal关键字。就像global那样。

def h1(x):
    def h2():
        nonlocal x
        x *= x
        return x 
    return h2
print(h1(2)())
结果：
4

2.10 两个BIF filter( ) 和 map( )

2.10.1 filter( )

filter( ) 有两个参数。第一个参数可以是函数或None。如果是函数，则将第二个可迭代数据里的每一个元素作为函数的参数进行计算，把结果为Ture的返回值筛选出来。如果是None，则将第二个参中为Ture的值筛选出来。

listx = [1,2,3,0]
i = filter(None,listx)
print(list(i))
结果：
[1, 2, 3]

#要求输出10以内的奇数
print(list(filter(lambda x: x%2,range(10))))
结果：
[1, 3, 5, 7, 9]

2.10.2 map( )

map( )也有两个参数，一个函数和一个序列，将序列的每一个元素作为函数的参数进行运算，直到序列的每个元素都加工完毕，返回值为序列。
map(function, iterable, ...)
function -- 函数，有两个参数
iterable -- 一个或多个序列
Python 2.x 返回列表。
Python 3.x 返回迭代器。

#计算两个列表想家
print(list(map(lambda x,y: x+y,[1,2,3],[1,2,3])))
结果：
[2, 4, 6]