匿名函数 列表生成式 字典生成式 递归

匿名函数(lambda)

语法

语法格式为 lambda 参数1,参数2,参数(参数可以省略):逻辑表达式(即结果,不可省略),参数的范围(可省略)　

常用格式

lambda 参数:结果

lambda x, y: x*y；函数输入是x和y，输出是它们的积x*y
lambda:None；函数没有输入参数，输出是None
lambda *args: sum(args); 输入是任意个数的参数，输出是它们的和(隐性要求是输入参数必须能够进行加法运算)
lambda **kwargs: 1；输入是任意键值对参数，输出是1

一般是组合使用  　

# map 映射
l = [1, 2, 3, 4, 5, 6]
print(list(map(lambda x: x + 5, l)))  # 基于for循环  此处l就是参数x 的范围  
# [6, 7, 8, 9, 10, 11]

　　

列表生成式(三元表达式)

语法格式

条件成立结果 if 条件 else 条件不成立结果 条件范围(可不写)

1. 结合函数结合使

def max(x,y):
　　return x if x>y else y  # 比较值大小　　

2. 结合匿名函数使用

map(lambda x,y:x-y if x> y else y-x, [2,1,3],[4,3,1])  # 两个列表相减并保证不为负

# [2, 2, 2]

3. 结合列表推导使用　

# 示例一: 将0-9的10个数，奇数用0表示，偶数用1表示
[0 if i % 2 == 0 else 1 for i in range(10)]             

# [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

　　

字典生成式(字典推导式)

字典推导式和三元表达式用法基本一致

语法

'''
语法一：
key：字典中的key
value：字典中的value
dict.items()：序列
condition：条件表达式
key_exp：在for循环中，如果条件表达式condition成立(即条件表达式成立)，返回对应的key, value并作key_exp, value_exp处理
value_exp：在for循环中，如果条件表达式condition成立(即条件表达式成立)，返回对应的key, value并作key_exp, value_exp处理

{key_exp: value_exp for key, value in dict.items() if condition}


语法二：
key：字典中的key
value：字典中的value
dict.items()：序列
condition：条件表达式
key_exp：在for循环中，如果条件表达式condition成立(即条件表达式成立)，返回对应的key, value并作key_exp, value_exp处理
value_exp1：在for循环中，如果条件表达式condition成立(即条件表达式成立)，返回对应的key, value并作key_exp, value_exp1处理
value_exp2：在for循环中，如果条件表达式condition不成立(即条件表达式不成立)，返回对应的key, value并作key_exp, value_exp2处理

{key_exp: value_exp1 if condition else value_exp2 for key, value in dict.items()}
'''　

案例

user_dict = dict()
for i in range(5):
    user_dict[i] = i ** 2
print(user_dict)

# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

user_dict = {x: x ** 2 for x in range(5)}
print(user_dict)
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 获取其中的奇数k,v

original_dict = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
user_dict = {k: v for k, v in original_dict.items() if v % 2 ==1}
print(user_dict) # {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

递归　

递归的官方解释 比较绕口   我一般就理解为函数内部调用自己就是递归了　

递归特点

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

关于递归还有两个名词，可以概括递归实现的过程

递推：像上边递归实现所拆解，递归每一次都是基于上一次进行下一次的执行，这叫递推

回溯：则是在遇到终止条件，则从最后往回返一级一级的把值返回来，这叫回溯

最大递归深度

python当中一般认为是 998

 

案例

1、递归求阶乘

# 1！+2！+3！+4！+5！+...+n!
def factorial(n):
    ''' n表示要求的数的阶乘 '''
    if n==1:
        return n # 阶乘为1的时候，结果为1,返回结果并退出
    n = n*factorial(n-1) # n! = n*(n-1)!
    return n  # 返回结果并退出
res = factorial(5) #调用函数，并将返回的结果赋给res
print(res) # 打印结果

2、递归推斐波那契数列

# 1，1，2，3，5，8，13，21，34，55，试判断数列第十五个数是哪个？
def fabonacci(n):
    ''' n为斐波那契数列 '''
    if n <= 2:
        ''' 数列前两个数都是1 '''
        v = 1
        return v # 返回结果，并结束函数
    v = fabonacci(n-1)+fabonacci(n-2) # 由数据的规律可知，第三个数的结果都是前两个数之和，所以进行递归叠加
    return v  # 返回结果，并结束函数
print(fabonacci(15)) # 610    调用函数并打印结果

　　

　

　

3、二分法找有序列表指定值

data = [1,3,6,13,56,123,345,1024,3223,6688]
def dichotomy(min,max,d,n):
    '''
    min表示有序列表头部索引
    max表示有序列表尾部索引
    d表示有序列表
    n表示需要寻找的元素
    '''
    mid = (min+max)//2
    if mid==0:
        return 'None'
    elif d[mid]<n:
        print('向右侧找！')
        return dichotomy(mid,max,d,n)
    elif d[mid]>n:
        print('向左侧找！')
        return dichotomy(min,mid,d,n)
    else:
        print('找到了%s'%d[mid])
        return 
res = dichotomy(0,len(data),data,222)
print(res)