Python学习 - 函数(2)

Python学习 - 语法入门：https://blog.csdn.net/wanzijy/article/details/125287855
Python学习 - 数据类型：https://blog.csdn.net/wanzijy/article/details/125341568
Python学习 - 流程控制：https://blog.csdn.net/wanzijy/article/details/125400906
Python学习 - 运算符(操作符)：https://blog.csdn.net/wanzijy/article/details/125387919
Python学习 - 列表：https://blog.csdn.net/wanzijy/article/details/125457990
Python学习 - 字典：https://blog.csdn.net/wanzijy/article/details/125567225
Python学习 -元组和集合：https://blog.csdn.net/wanzijy/article/details/125577609
Python学习 - 函数(1)：https://blog.csdn.net/wanzijy/article/details/125669084
Python学习 - 函数(2)：https://blog.csdn.net/wanzijy/article/details/125739981

递归式的函数，其实就是函数在自己调用自己
无穷递归：如果这个函数被调用，程序的内存会溢出，效果类似于死循环
递归是解决问题的一种方式

递归式函数的两个要件：

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

def factprial1(n) :
    '''
    递归函数，用来求任意数的阶乘
    :param n:
    :return:
    '''
    if(n == 1) :
        return 1
    return n * factprial1(n - 1)

函数是一等对象，一等对象一般都有如下特点：

• 对象在运行时创建
• 能赋值给变量或作为数据结构的元素
• 能作为参数传递
• 能作为返回值返回
  
  

高阶函数，要至少符合以下两个特点中的一个：

• 接收一个或多个函数作为参数
• 将函数作为返回值返回

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

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


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

def fn4(i):
    if (i % 4 == 0):
        return True
    return False

def fn(lst, func) :
    '''
    根据传进去的函数参数，决定这个函数是什么功能
    :param lst: 指定的参数列表
    :param func: 定义的规则，函数
    :return:
    '''
    new_list = []
    for n in lst :
        if(func(n)) :
            new_list.append(n)
    return new_list

filter()

• 从序列中过滤出符合条件的元素，保存到一个新的序列中
• 参数：
  1. 函数，根据该函数来过滤序列
  2. 需要过滤的序列
• 返回值：过滤后的新序列
  
  

lambda 函数表达式（语法糖）：

• 用来创建一些简单的函数，是创建函数的又一种方式
• 语法：   lambda 参数列表 : 返回值
• 也可以将匿名函数赋值给一个变量

def fn5(a, b) :
    return a+b

lambda a, b : a + b  #  声明
print((lambda a, b: a + b)(10, 20))  #  调用

当有 lambda 表达式后，第八节的高阶函数就可以改造成

l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def fn4(i):
    return i % 4 == 0
print(list(filter(fn4, l)))
print(list(filter(lambda i : i % 4 == 0, l)))

sort()

• 用来对列表中的元素进行排序，会直接改变原本列表
• 默认是直接比较列表中的元素的大小

l = ['bb', 'aaaa', 'c', 'dddddddd', 'fff']
l.sort();
print(l)  #  ['aaaa', 'bb', 'c', 'dddddddd', 'fff']

在 sort() 可以接收一个关键字参数
key 需要一个函数作为参数，当设置了函数作为参数，每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小

l = ['bb', 'aaaa', 'c', 'dddddddd', 'fff']

l.sort(key=len)  #  此时会根据每个字符串的长度来进行排序
print(l)  #  ['c', 'bb', 'fff', 'aaaa', 'dddddddd']

l = [2, 5, '1', 3, '6', '4']
l.sort(key=str)  #  将元素转换为字符串再比较，也可以转为整型再比较，不会改变原来的元素类型，但是顺序会被改变
print(l)  #  ['1', 2, 3, '4', 5, '6']

sorted()

• 用法基本和 sort() 函数一致，但是 sorted() 可以对任意的序列进行排序
• 并且使用sorted()排序不会影响原来的对象，而是返回一个新对象

l = [2, 5, '1', 3, '6', '4']
print(sorted(l, key=int))  #  ['1', 2, 3, '4', 5, '6']
print(l)  #  [2, 5, '1', 3, '6', '4']

l = '27287328248193874834'
print(sorted(l, key=int))  #  ['1', '2', '2', '2', '2', '3', '3', '3', '4', '4', '4', '7', '7', '7', '8', '8', '8', '8', '8', '9']

map() ：可以对可迭代对象中的所有元素做指定的操作(比如全部元素都加1)，然后将其添加到一个新的对象中返回

l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
r = map(lambda i : i + 1, l)
print(list(r))

将函数作为返回值返回的高阶函数，叫做闭包
通过闭包，可以创建一些只有当前函数能访问的变量，将一些私有的数据藏到闭包中

形成闭包的条件：

• 函数嵌套
• 将内部函数作为返回值返回
• 内部函数必须要使用到外部函数的变量

使用闭包可以保护一些内部的变量，防止外面去篡改，比如下面的 nums 列表

def make_averager() :
    nums = []
    def averager(n) :
        nums.append(n)
        return sum(nums) / len(nums)
    return averager
averager = make_averager()
print(averager(10))  #  10.0
print(averager(20))  #  15.0
print(averager(30))  #  20.0

不修改原函数内部的情况下，来对函数进行扩展

装饰器的好处：

• 可以修改多个函数
• 方便后期的维护
• 不违反开闭原则（OCP）

def fn() :
print('我是fn函数')

def add(a, b) :
    return a + b

def mul(a, b) :
    return a * b

def begin_end(old) :
    '''
    用于对其他函数进行扩展，使其他函数可以在执行前打印开始执行，执行后打印执行结束
    :param old: 要进行扩展的函数
    :return:
    '''

    def new_function(*args, **kwargs) :
        print('开始执行......')
        result = old(*args, **kwargs)
        print('执行结束......')
        return result
    return new_function

f = begin_end(fn)
f()

f2 = begin_end(add)
print(f2(12, 34))

fn3 = begin_end(mul)
print(fn3(12, 34))

调用时，会在函数的调用前和后打印 “开始执行” 和 “结束执行”

在定义函数时，可以通过“@”装饰器，来使用指定的装饰器，来使用指定的装饰器，来装饰当前函数

def begin_end(old) :
    def new_function(*args, **kwargs) :
        print('开始执行......')
        result = old(*args, **kwargs)
        print('执行结束......')
        return result
return new_function

@begin_end  #  这种用法较为常用
def say_hello() :
    print('大家好')

可以同时为一个函数指定多个装饰器，这样函数将会按照从内向外的顺序被装饰

def begin_end(old) :
    def new_function(*args, **kwargs) :
        print('开始执行......')
        result = old(*args, **kwargs)
        print('执行结束......')
        return result
    return new_function

def test(old) :
    def new_function(*args, **kwargs) :
        print('test开始执行......')
        result = old(*args, **kwargs)
        print('test执行结束......')
        return result
return new_function

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

say_hello()

执行结果：