函数递归，生成器，匿名函数

一：递归函数#

（1）定义：函数在调用的过程中 直接或者间接调用本身

例如：

　　（1）直接调用函数本身

def index():
    print('递归函数')
    index()     # 在函数内部再次调用函数本身
index()

　　（2）间接调用函数

def index():
    print('递归函数')
    func()     


def func():
    print('间接调用函数')
    index()     # 调用上输入index 但是index内部又含有本部的函数调用方式
func()

 

（2）函数调用最大深度：

作用：当函数递归调用的时候 在局部依旧会开辟一个名称空间 无限次调度占用内存 为了解决内存占用 python对函数最大递归做了限制

（1）默认最大限制1000 但是不精确 而且可以手动更改最大限制

（2）基本限制范围在997/998左右

例如：　

import sys
sys.getrecursionlimit()

def index(n):
    print('检测递归次数',n)
    index(n+1)  # 每次调用函数次数+1
index(1)        # 检测次数 998

PS：无限制递归相当于死循环没有意义 

 

（3）：递归函数调用的过程

　　（1）回溯过程：逐层从外向内查找，明确一个结束条件，查找的过程就是逐渐靠近结束条件的过程

　　（2）递推过程：从结束条件 向外部逐渐逆推

例如：

　　

'''
PS：案例一
递归查找年龄的过程
age(5) = age(4) + 2
age(4) = age(3) + 2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 18
'''
#
def index(n):
    if n == 1:              # 结束条件
        return 18
    return index(n-1)+2     # 递归调用函数
res = index(5)
print(res)

# PS:案例二 循环打印容器类型
number = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,]]]]]]]]]]]]]
def index(number):
    for i in number:
        if type(i) is int:  # 如果取值的类型是整形打印
            print(i)  
        else:               # 否则重新调用函数进行打印 
            index(i)
index(number)

 

二：算法之二分法#

算法：能够高效率的解决某些问题

例如：

l = [1,3,5,12,57,89,101,123,146,167,179,189,345]
num = 167
for i in l:
    if num == i:
        print('找到啦')
# PS:如果数字在尾部 依次循环打印效率会很低

二分法：

基本思路：

（1）必须有有大小顺序

（2）从中间将列表切分 取出中间值 和目标值进行比较 通过比较如果相等直接切分 否则继续切分比较

例如：

　　

l = [1,3,5,12,57,89,101,123,146,167,179,189,345]
target_num = 101
def index(l,target):
    middle_num = len(l)//2                 # 将列表平均切分
                                            
    if target_num > l[middle_num]:        # 比较目标函数和中间函数大小
        num_right = l[middle_num + 1:]    # 大于则向右边切分
        index(num_right,target_num)       # 再次比较切分之后的大小

    elif target_num < l[middle_num]:
        num_left = l[0:middle_num]
        index(num_left,middle_num)

    else:
        print('find it')
index(l,target_num)                     # find it

 

 三：三元表达式#

作用：在条件判断下 更加简洁

例如：

x = 99
y = 100
res = x if x >y else y
print(res)  # 100

PS：如果if后面的条件成立 则返回前面的 反之返回else所对应的值

例题：

is_free = input('请输入是否免费(y/n)>>>:')
is_free = '免费' if is_free == 'y' else '收费'
print(is_free)

 

四：生成器#

作用：

（1）生成列表 字典 元组的工具

（2）其会将返回结果 保存在生成器中 当你需要的时候可以提取 节省内存空间

【1】

列表生成式

例如：

# 将列表user_info元素尾部加上_SR
user_info = [1,2,3,4, ]
info = []
for i in user_info:
    info.append('%s_SR'%i)
print(info)  # ['1_SR', '2_SR', '3_SR', '4_SR']


'''
 (1)通过for循环将列表元素取出
（2）将取出的元素与前面的占位符进行拼接
'''
user_info = [1,2,3,4]
user_info1 = ['%s_SR'%i for i in user_info]
print(user_info1)

 

（2）生成器跟条件语句

例如：

# 取出不带_SR的元素生成新的列表
number = ['1_SR', '2_SR', '3_SR', '4_SR','5_NB']
user_info = [i for i in number if i.endswith('_SR')]
print(user_info)  # ['1_SR', '2_SR', '3_SR', '4_SR']
'''
 (1)首先执行for循环
（2）判断条件语句
（3）符合条件语句的才会将元素返回给for之前的变量
（4）如果都不符合 则会返回一个空列表

'''

PS：其不能再后面跟从else 因为在该生成器中有for 以及 if两者都可以跟else 如果在列表中加入了else 则不能知道else是归属于哪个

 

【2】

（1）字典生成式：

# 需求将两个列表组成字典的形式
l1= ['name','age']
l2 = ['SR',18]

# 方法一
dict = {}
for i,j in enumerate(l1):   # 将l1通过枚举选出序号以及序号对应的值
    dict[j] = l1[i]        #  通过将值取出来 与列表序号对应
print(dict)               #  {'name': 'name', 'age': 'age'}

# 方法二：
user_info = ['SR',18]
dict = {i:j for i,j in enumerate(user_info)}  # 枚举将序号以及对应值取出 然后拼接成字典的形式

 

（2）列表生成式跟条件语句

user_info = ['SR',18]
dict = {i:j for i,j in enumerate(user_info) if j != 18}  # 枚举将序号以及对应值取出 然后拼接成字典的形式
print(dict)  # {0: 'SR'}

PS：如果条件语句所对应值为假 则会丢弃该值

 

五：匿名函数#

定义：没有函数名的函数

特点：

（1）调用一次 函数消失

（2）其一般不会单独使用 与内在函数一起使用

基本定义形式：

 lambda x,y:x + y
 # x,y:表示形参
 # x+y:表示返回值

 

 六：常用内置函数

max 关联匿名函数

作用：大小

例如：

# 通过最大value 取出对应的key
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

print(max(salaries,key=lambda key:salaries[key]))  
# 通过 salaries[key] 取出字典的value 取出的value与前面的key对应 即通过value比较大小

 

map 

作用：

（1）将某个元素与某个元素映射起来 控制返回的结果

（2）映射结果是一串地址 需要取值的时候通过地址取值

例如：

# 将l的列表都+1
l = [1,2,3,4,]
print(map(lambda x:x+1 ,l))          # <map object at 0x0000000002237358>
print(list((map(lambda x:x+1 ,l))))  # [2, 3, 4, 5]

 

zip:

作用：

（1）类似于拉链将两个元素组合起来

（2）返回值也是一串地址 需要取值的时候通过该地址取值

（3）返回值是一个元组

例如：

user_info = ['name','age']
user_info1 = ['SR',18]
print(zip(user_info,user_info1))        # <zip object at 0x00000000027EDAC8>
print(list(zip(user_info,user_info1)))  # [('name', 'SR'), ('age', 18)]

 

filter：

作用：

（1）可以将某些元素进行过滤

（2）返回值也是一串地址 需要取值的时候通过该地址取值

例如：

 

number = [1,2,3,4,5]
print(list((filter(lambda x:x==3,number))))  # [3]

 

sorted:

作用：将列表元素按照升序的方式排序

例如：

number = [5,4,3,2,1]
print(sorted(number))  # [1, 2, 3, 4, 5]

 

 reduce

作用：

PS：使用之前需要调用模块：from functools import reduce

（1）其会将多个元素整合成一个元素返回出来

（2）整合元素的规则 根据其所携带的匿名函数

例如：

from functools import reduce

number = [1,2,3,4,]
print(reduce(lambda x,y:x+y,number))  # 10

'''
 (1) 首先前两个元素会相加
（2）接下来会将前两个元素相加的结果依次与后面的元素相加
'''