复习python函数

1.对函数的理解
- 函数的传递方式
- 返回值 return
- 可通过help()函数查看函数说明
- 作用域
2.不定长参数
3.递归
4.高阶函数
- 将函数作为参数传递
- 将函数作为返回值返回
5.匿名函数
6.装饰器

1.对函数的理解

函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用。

def fn():
	print('hello')
# 调用
fn()

函数的传递方式

（1）定义形参
可以为形参指定默认值

def fn(a=5, b=10, c=20):
    print(a, b, c)

（2）实参的传递方式
实参可以传递任意类型的参数

位置参数

fn(1,2,3)

关键字参数

fn(a=5, b=6, c=7)

混合使用关键字和位置参数，必须将位置参数写到前面

fn(1, 2,c=30)

返回值 return

def fn5():
    return 10
# fn5 和 fn5()区别
print(fn5)   # fn5是函数对象，打印fn5实际是在打印函数对象
print(fn5())   # fn5()是在调用函数，实际是打印函数的返回值 10

可通过help()函数查看函数说明

def fn(a:int, b:bool, c:str='hello')-> int:
    '''
    这是文档字符串实例
    :param a:整数参数
    :param b:布尔参数
    :param c:字符串参数
    :return:
    '''
    return 233

help(fn)

请添加图片描述

作用域

全局变量
局部变量
如果希望在函数内修改全局变量，则需要使用global关键字来声明变量

a = 20
def fn3():
    global a
    a = 10
    print(a)  # 10

fn3()
print(a)   # 10

2.不定长参数

在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参。
它将会将所有的实参保存到一个元组中。

a, b, *c = (1, 2, 3, 4, 5, 6)

*a会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）。

def fn(*a):
    print(a, type(a))

fn(1, 2, 3)

注意：带*的参数后的所有参数，必须以关键字参数的形式传递。

def fn2(*, a, b, c):
    print(a, b, c)
fn2(a=1, b=2, c=3)

*形参只能接受位置参数，而不能接受关键字参数。
**形参可以接受其他关键字参数，它会将这些参数统一保存到一个字典中。
字典的key就是参数的名字，字典的vaLue就是参数的值。

def fn3(**a):
    print('a=', a, type(a))
fn3(a=1, b= 2)

结果：

a= {'a': 1, 'b': 2} <class 'dict'>

解包

# 参数的解包
def fn4(a, b, c):
    print(a, b, c)

# *对元组、列表解包
t = (10, 20, 30)
t = [10, 20, 30]
fn4(*t)   # 10,20,30

# **对字典解包
d = {'a':100,'b':200, 'c':300}
fn4(**d)   # 100,200,300

3.递归

递归式函数，在函数中自己调用自己。
递归式函数两个条件：
1.基线条件

问题可以被分解为的最小问题，当满足基线条件时，递归就不在执行了

2.递归条件

将问题继续分解的条件

# 求N!
def factorial(n):
    # 基线条件
    if n == 1:
        return 1

    # 递归条件
    return n * factorial(n-1)

# print(factorial(10))

# 创建一个函数，用来检查是否是回文字符串，如果是返回True,否则返回False
# 回文字符串，字符串从前往后念和从后往前念是一样的
def hui_wei(s):
    if len(s) < 2:
        return True
    elif s[0] != s[-1]:
        return False
    # 递归条件
    return hui_wei(s[1:-1])

print(hui_wei('ababa'))

4.高阶函数

高阶函数将函数作为参数传递
接收函数作为参数，或者将函数作为返回值的函数是高阶函数。

将函数作为参数传递

l = [1, 2, 3, 4, 5, 6, 7, 8, 9]

def fn2(i):
    if i % 2 ==0:
        return True
    return False

def fn3(i):
    if i > 5:
        return True
    return False

# 将函数作为参数传递
def fn(func, l):
    # 创建一个列表
    list = []
    # 对列表进行筛选
    for n in l:
        if func(n):
            list.append(n)

    return list
print(fn(fn2, l))

将函数作为返回值返回

将函数作为返回值返回，也是一种高阶函数,也称为闭包。
通过闭包可以创建一些只有当前函数能访问的变量，也可以将私有数据藏在闭包中。
形成闭包条件：
1.函数嵌套
2.将内部函数作为返回值返回
3.内部函数必须要使用到外部函数的变量

def fn():
    a = 10
    # 函数内部再定义一个函数
    def inner():
        print('我是fn2', a)
    # 将内部函数 inner作为返回值返回
    return inner
fn()()

5.匿名函数

lambda函数表达式专门用来创建一些简单的函数，他是函数创建的又一种方式。
语法：lambda 参数列表：返回值

def fn(a, b):
    return a + b
# 等价于上面的函数
lambda a,b : a+b

# 运用场景
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# filter()方法不会把你的参数怎么样，但它像HR一样，决定你的去留
r = filter(lambda i: i < 5, l)
print(list(r))

# map()
# map()方法做逻辑运算（and or &）/运算符运算处理（+ - * /）
# 也就是map()一定会加工你的参数
# map()函数可以对可迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回
r = map(lambda i : i**2, l)
print(list(r))

6.装饰器

通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展。

def begin_end(old):
    """
    用来对其他函数进行扩展
    :param old: 要扩展的函数对象
    :return:
    """
    def new_function(*args, **kwargs):
        print("开始执行~")
        # 调用被扩展的函数
        result = old(*args, **kwargs)
        print('执行结束~')

    return new_function
@begin_end
def say_hello():
	print('大家好')
say_hello()