Python_函数

函数

函数的定义：函数是指将一组语句的集合通过一个名字（函数名）封装起来，想要执行这个函数，只需调用其函数名即可。

函数的特性：

减少重复代码；
方便修改，更易扩展；
保持代码的一致性。

函数名命名规则：

函数名必以下划线或者字母开头，可以包含任意字母、数字或下划线的组合，不能使用任何标点符号；
函数名是区分大小写的；
函数名字不能是保留字。

语法定义：

def add(a, b):                                        # 函数名
    print(a + b)
add(3,7)                                              # 调用函数

一、函数的参数

形参与实参：

形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即可释放所分配的内存单元。因此，形参只有在内部有效。函数的调用结果返回主调用函数后则不能再使用此形参变量。

实参：实参可以使常量、变量、表达式、函数等，无论实参是任何类型的量，在进行函数调用时，他们都必须有确定的值，以便把这些值传送给形参，因此预先用赋值、输入等办法使参数获得确定值。

def add(a, b):                                              # a, b 为形参数
    res = a + b
    return res
c = add(3, 4)                                               # 3， 4 为实参
print(c)

函数参数：

必须参数
关键字参数
默认参数
不定长参数

必须参数：必须参数必须以正确的顺序传入参数，调用时的数据必须和声明时的一样。

def mu_info(name, age):
    print('Name:%s 
Age:%d' % (name, age))

mu_info('wj', 24)

关键字参数：传入参数的时候带上关键字，即使顺序不对，依然可以辨识。

def mu_info(name, age):
    print('Name:%s 
Age: %d' % (name, age))

mu_info(age=24, name='wj')

默认参数：形参定义时就确定好的值调用参数的时候可以省略。

必选参数在前，默认参数在后，否则Python解释器会报错，

当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面，变化小的参数可以作为默认参数。

def mu_info(name, age, sex='male'):
    print('Name:%s 
Age: %d 
sex:%s
' % (name, age, sex))
mu_info('wj', 24)
mu_info('zl', 24)
mu_info('cf', 25, 'female')

不定长参数：不定常参数可以处理比当初声明时更多的参数。不定长参数和其他三种参数不同，声明时不会命名。

*args指的是接受所有无命名参数

def add(*args):
    sum = 0
    for i in args:
        sum = sum + i
    print(sum)

add(1, 2, 3, 4)

**kwargs指的是接受键值对的参数保存方式为字典，进行函数内部运算。

def print_info(**kwargs):
    for i in kwargs:
        print('%s:%s' % (i, kwargs[i]))

print_info(name='mu', age='18', sex='male', job='Linux', height=180)

不定长参数的位置：*args只能放左边。**kwargs只能放右边不能改变，实参也要按照这个位置顺序来，不然无法保存。

def print_info(*args, **kwargs):
# def print_info(**kwargs,*args):                                                       # 错误示范
    for i in args:
        print(i)
    for o in kwargs:
        print('%s:%s' % (o, kwargs[o]))

print_info('mu', 24, sex='male', job='Linux', height=180)
# print_info(sex='male', 'mu, 24, job='Linux', height=180)                              # 错误示范
# print_info(sex='male', job='Linux', height=180, 'mu', 24)                             # 错误示范

不定长参数+默认参数

　　如果有默认参数，放左边。

def print_info(sex='male', *args, **kwargs):
    print(sex)
    print(args)
    print(kwargs)

# print_info()
print_info('mu', 1, 2, 3, job='Linux')                  # sex 没有打印，因为传入的参数‘mu’占用了sex的位置，所以单独打印了‘mu’，如不是把它打印在元组中

　　标准顺序

def func(name, age=22, *arge, **kwargs)

二、函数的作用域

python中的作用域分4种情况：
　　L: local，局部作用域，即函数中定义的变量；
　　E: enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；
　　G: globa，全局变量就是模块级别的定义的变量；
　　B: built-in，系统固定模块里的变量，比如：int，byrearray等。
搜索变量的优先级顺序依次是：局部作用域 > 外层作用域 > 当前模块中的全局 > python内置作用域，也就是LEGB。

局部作用域不能修改全局作用域的变量，如果想要修改，需要用global声明。

name = "全局作用域"
def change_name(name):
    print("打印的是那个？:", name)
    name = "局部作用域"
    print("重新赋值后打印的是那个？:" , name)

change_name(name)
print("全局作用域是否发生改变？：", name)

name = "全局作用域"
def change_name():
    global name
    print("打印的是那个？:", name)
    name = "局部作用域"
    print("重新赋值后打印的是那个？:" , name)

change_name()
print("全局作用域是否发生改变？：", name)

内层局部作用域不能修改外层作用域的变量，如果想要修改，需要用nonlocal声明。

def change_one():
    name = "外层作用域"
    print(name)
    def change_two():
        name = "局部作用域"
        print(name)
    change_two()
    print(name)
change_one()

def change_one():
    name = "外层作用域"
    print(name)
    def change_two():
        nonlocal name
        name = "局部作用域"
        print(name)
    change_two()
    print(name)
change_one()

小结：

1. 变量查找顺序： LEGB，局部作用域 > 外层作用域 > 当前模块中的全局 > python内置作用域
2. 只有模块、类、及函数才能引入新作用域
3. 对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量
4. 内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个关键字，就讷讷个完美的实现闭包了。

三、函数返回值

想要获取函数的执行结果，可以用return语句将结果返回。

注意：

　　函数里如果没有return，结束时默认会返回一个None；

　　return后可以返回多个对象，如果是多个对象，python会帮我们把多个对象封装为一个元组，元组中的元组就是各个对象；

　　函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束。

def f():
    print('ok')
    return
    # return None                                         # 如果不写，python，默认追加这个
print(f())

四、高阶函数

定义：变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

高阶函数特点：

函数名可以进行赋值；
函数名可以作为函数参数名还可以作为函数的返回值。

作为函数名：

def f(n):
    return n * n

def test(a, b, func):
    res = func(a) + func(b)
    return res

print(test(3, 2, f))

作为函数的返回值：

def foo():
    def test():
        return 8
    return test                                                     # 其实此时foo() = test

ret = foo()
print(ret)                                                          # 打印的就是还没有调用的test，也就是test的内存地址，想要调用，再在后边加（）就行，打印出来的就是test的值
print(ret())
print(foo())
print(foo()())

五、递归函数

递归的特性：

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

递归算阶乘：

# 正常算阶乘
def f(n):
    num = 1
    for i in range(n):
        num = (i + 1) * num
    return num
print(f(5))


# 递归引用自己
def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)
print(fact(5))

斐波那契数列：

# 正常算法
def f(x):
    a, b = 0, 1
    n = 0
    while n <= x:
        # print(b)
        a, b = b, a + b
        n = n + 1
    return b
print(f(7))


# 引用自己
def fibo(n):
    if n <= 1:
        return n
    return  fibo(n - 1) + fibo(n -2)
print(fibo(5))

六、内置函数

filter：过滤器，需要两个参数。第一个参数是函数，第二个参数是一个序列，只过滤，不修改。

str = ['a', 'b', 'c', 'd']
def fun(n):
    if n != 'a':
        return n
ret = filter(fun, str)                                        # ret是一个迭代器对象
print(list(ret))

map：可对列表进行修改

str = ['a', 'b', 'c', 'd']
def fun(n):
    return n + 'mu'

ret = map(fun, str)                                           # ret是一个迭代器对象
print(list(ret))

reduce：接收参数时，一个函数f，一个列表，传入reduce的函数必须有两个参数，reduce对list中的每次参数反复调用函数f，并返回最终结果

from functools import reduce
def f(x, y):
    return x + y
print(reduce(f, range(1,10)))

lambda算法：lambda a, b : a + b

用内置函数算阶乘

from functools import reduce
print(reduce(lambda x, y : x * y, range(1,6)))