Python当歌（四）：函数

函数基础

函数是什么?

想象生活中的例子，修理工需要实现准备好工具箱里面放好锤子，扳手，钳子等工具，然后遇到锤钉子的场景，拿来锤子用就可以，而无需临时再制造一把锤子。

修理工===>程序员

具备某一功能的工具===>函数

要想使用工具，需要事先准备好，然后拿来就用且可以重复使用要想用函数，需要先定义，再使用。

函数分类

（1）内置函数

为了方便我们的开发，针对一些简单的功能，python解释器已经为我们定义好了的函数即内置函数。对于内置函数，我们可以拿来就用而无需事先定义，如len(),sum(),max()

（2）自定义函数

很明显内置函数所能提供的功能是有限的，这就需要我们自己根据需求，事先定制好我们自己的函数来实现某种功能，以后，在遇到应用场景时，调用自定义的函数即可。

（3）如何自定义函数？

语法：
    def 函数名(参数1,参数2,参数3,...):
        '''注释'''
        函数体
        return 返回的值

ps:函数名要能反映其意义

（4）函数使用的原则：先定义，再调用

函数即“变量”，“变量”必须先定义后引用。未定义而直接引用函数，就相当于在引用一个不存在的变量名

测试一：

测试二：

结论:函数的使用,必须遵循原则:先定义,后调用；我们在使用函数时,一定要明确地区分定义阶段和调用阶段。

#定义阶段
def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
#调用阶段
foo()

ps:函数在定义阶段只检测语法，不执行代码。也就说，语法错误在函数定义阶段就会检测出来，而代码的逻辑错误只有在执行时才会知道

(5)定义函数的三种形式

1、无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印

2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值

3、空函数：设计代码结构

例子：

结论：定义时无参，意味着调用时也无需传入参数；定义时有参，意味着调用时则必须传入参数

（6)调用函数

函数的调用：函数名加括号

• 先找到名字

• 根据名字调用代码

函数调用的三种形式：

• 语句形式：foo()

• 表达式形式：3*len('hello')

• 当中另外一个函数的参数：range(len('hello'))

函数返回值：

• 无return->None

• return 1个值->返回1个值

• return 逗号分隔多个值->元组

什么时候该有返回值？

调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值（通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果）

什么时候不需要有返回值？

调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值（通常无参函数不需要有返回值）

（7）函数的参数
形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定。

1、位置参数：按照从左到右的顺序定义的参数

位置形参：必选参数

位置实参：按照位置给形参传值

2、关键字参数：按照key=value的形式定义的实参

无需按照位置为形参传值

注意的问题：

• 关键字实参必须在位置实参右面
• 对同一个形参不能重复传值

3、默认参数：形参在定义时就已经为其赋值

可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）

注意的问题：

• 只在定义时赋值一次
• 默认参数的定义应该在位置形参右面
• 默认参数通常应该定义成不可变类型

4、可变长参数：

可变长指的是实参值的个数不固定

而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args（列表），**kwargs（字典）

测试：*args

测试：**kwargs

5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递可以保证，传入的参数中一定包含某些关键字。

函数的变量、递归以及内置函数

局部变量和全局变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

name='xwq'
def change_name():
    print('我的名字',name)  #全局变量起作用
change_name()

def change_name():
    name='帅了一笔'
    print('我的名字',name)      #局部变量起作用
    change_name()
print(name)

def change_name():
    global name
    name='帅了一笔'
    print('我的名字',name)      #因为global参数全局变量变为‘帅了一笔’而非xwq,
change_name()

ps：nonlocal参数

name = "lf"
def weihou():
    name = "xwq"
    def weiweihou():
        nonlocal name   # nonlocal，指定上一级变量，如果没有就继续往上直到找到为止
        name = "冷静" 
    weiweihou()
    print(name)
print(name)
weihou()
print(name)

运行结果为：

lf
冷静
lf

嵌套函数和作用域

name = "xwq"

def change_name():
    name = "xwq2"

    def change_name2():
        name = "xwq3"
        print("第3层打印",name)

    change_name2() #调用内层函数
    print("第2层打印",name)

change_name()
print("最外层打印",name)

此时，在最外层调用change_name2()会出现什么效果？没错，出错了， 为什么呢？
作用域在定义函数时就已经固定住了，不会随着调用位置的改变而改变。

例一：

name='alex'

def foo():
    name='lhf'
    def bar():
        print(name)
    return bar

func=foo()
func()

例二：

name='alex'

def foo():
    name='lhf'
    def bar():
        name='wupeiqi'
        def tt():
            print(name)
        return tt
    return bar

func=foo()
func()()

递归调用

在函数内部，可以调用其他函数。如果在调用一个函数的过程中直接或间接调用自身本身

def calc(n):
    print(n)
    if int(n/2) ==0:
        return n
    return calc(int(n/2))

calc(10)

输出：

10
5
2
1

递归特性:

• 必须有一个明确的结束条件
• 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
• 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

内置函数

（1）zip()函数

zip()函数接受0个或多个序列作为参数，返回一个tuple列表。

zip()函数具体的工作机制是，将每个列表中同一位置的元素取出来组成一个元组，存放到一个列表中，然后返回这个列表。举例说明：

对于长度不同的seq，zip()函数处理;

从上面的例子可以看出，当seq的长度不一致时，zip()会以最短的那个seq为主，进行处理，然后将多余的舍弃掉.

zip()对只有一个seq的处理：

(2)map()函数

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。举例说明：

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

map（）可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

(3)reduce()函数

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。举例说明：

(4)filter()函数

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

例如，在一个list中，删掉偶数，只保留奇数，可以这么写：

把一个序列中的空字符串删掉，可以这么写：

可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。

注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

(5)sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

此外，sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

(6)max()/min()函数

max(iterable, key, default) 求迭代器的最大值，其中iterable 为迭代器，max会for i in … 遍历一遍这个迭代器，然后将迭代器的每一个返回值当做参数传给key=func 中的func(一般用lambda表达式定义) ，然后将func的执行结果传给key，然后以key为标准进行大小的判断。

以下根据不同的判断条件返回最大值也不同