函数篇：三元表达式、生成式、匿名函数、常见内置函数

2022.3.22学习笔记

• 三元表达式
• 各种生成式
• 匿名函数
• 常见重要内置函数
• 常见内置函数补充

一、三元表达式

使用场景：数据二选一的时候，推荐使用三元表达式

结构：

结果1+条件if判断+else+结果二

注意：if条件成立输出左边的结果1，反之输出右边的结果2

复制代码
1
2
3
4
a = 4
b = 3
print(a if a > b else b )  # 结果为3
注意：三元表达式一般用于二选一，也可以嵌套使用，但是最好不要嵌套，保持代码整洁

另外，针对if分支补充，有简化版本，可以这样写：

复制代码
1
2
3
name = 'jason'
if name == 'jaosn':print(name)
else:print('哈哈哈')  # 这样不换行写也可以，但是最好不这样写

二、各种生成式

1、列表生成式

就是在原有列表基础上生成一个新的列表，并进行相应处理，如：

复制代码
1
2
3
4
5
name_list = ['jaosn', 'tony', 'jerry', 'marry']
# 需求：将列表中所有人名都加上'666'
利用学过的知识，我们自然会想到for循环，但是这里有个简单的方法，列表生成式
res = [name + '666' for name in name_list]
# 这里的意思是，将列表name_list进行for循环，每次循环获得的值放入左边name+'666'进行处理，由此得到一个新的列表

这就是列表生成式，利用这种方式我们就可以简单地对列表批量进行同样地操作或者改动了

2、字典生成式

同样字典也有生成式，并且跟列表生成式一样使用for循环

可以将两个列表的元素组成键值对，前提两个列表元素个数一致，举例如下：

复制代码
1
2
3
4
5
6
7
l1 = ['name', 'age', 'pwd']
l2 = ['jason', 18, 123]
# 需求：将两个列表组成键值对
他的生成方式和列表相似，但是需要引用range参数代替索引值
res = {l1[i]:l2[i] for i in range(len(l1))}
# 这样也是使用for循环，只不过左边的数据处理是利用右边索引值
注意：列表和字典生成后边也可以加上if判断，但是不能再加else，因为for循环也可加else，所以容易导致混乱

3、集合生成式

同样的，集合也可以快速生成，如：

复制代码
1
2
res = {i for i in range(10)}  # 得到0-9的数字集合
res = {i for i in range(10) if i != 2}  # 也可衔接if条件

那么有没有元组生成式呢，答案是没有的，因为元组依据上述写法得到的是后续即将要学的迭代器

三、匿名函数

匿名函数，顾名思义就是没有函数名，一般匿名函数是结合其他函数或者结构进行使用的

复制代码
1
2
3
4
5
6
# 定义匿名函数
lambda x:x+2
结构：lambda 形参：返回值，等同于下面这个函数
def index(x):
    return x+2
注意：冒号后面的数据既可以是具体数据或者变量，也可以是判断比如x>2,一般是和其他函数结合使用时，处理多个元素，意思是x>2的数据

结合max：统计最大值

复制代码
1
2
l1 = [11,32,41,22,13,66,54,78,96,34,54,99,35]
print(max(l1))  # 结果是l1列表中最大的元素值

max()也可以使用多个参数求字典的最大值，结构是：

max（l1， key = func）左边是字典，右边是函数

这个函数可以使用匿名函数代替,如下：

复制代码
1
2
3
l1 = {'jason':123, 'tony':321, 'jack':456}
print(max(l1, key = lambda key:l1[key]))  # 结果是456，就是将左边字典的每一个元素丢到右边函数进行处理，得到的结果组成一个数据集取最大值

四、常见重要内置函数

1、map映射

结构：map(函数，数据集)

作用：可以对数据集进行批量操作

复制代码
1
2
3
4
l1 = [1, 2, 3, 4, 5]
# 需求：所有元素加10
res = map(lambda x:x+10, l1)  # 结果是个对象
print(list(res))  # [11,12,13,14,15] 需要先用list转为列表

2、zip拉链

结构：zip（数据集1，数据集2...）

作用：可以将两个或者多个数据集的元素一一对应

复制代码
1
2
3
4
5
6
l1 = [11, 22, 33, 44]
l2 = ['jaosn', 'tony', 'jerry', 'jack']
# 需求：将两个列表元素一一对应组队
res = zip(l1,l2)  # 结果是个对象，赋值给res
print(list(res))  # [(11,'jason'), (22, 'tony'), (33,'jerry'), (44, 'jack')]
注意：zip可以整合多个数据集，并且每个数据集len可以不一致，只取最短的那个!

3、filter过滤

结构：

filter（函数，数据集）

作用：可以根据指定条件筛选出需要的数据

复制代码
1
2
3
4
l1 = [11, 22,, 33, 44, 55]
# 需求：筛选出大于30的元素
res = filter(lambda x:x>30, l1)  # 结果也是个对象
print(list(res))  # [33,44,55]

4、reduce归总

结构：

from functools import reduce

reduce(函数名，数据集)

作用：可以将数据集所有数据值相加

复制代码
1
2
3
4
5
l1 = [11, 22, 33]
# 需求：求l1所有元素之和
from functools import reduce
res = reduce(lambda x,y:x+y, l1)  # 66
res = reduce(lambda x,y:x+y, l1, 100)  # 166，相当于计算结果加100

课堂练习

编写一个二分法(快排)和装饰器

统计二分法(快排)执行的时间 数据自己模拟

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def get_time(func):
    def inner(*args, **kwargs):
        import time
        a = time.time()
        res = func(*args, **kwargs)
        b = time.time()
        # time.sleep(1)
        print(b - a)
        return res
    return inner


l = [12,34,56,78,90,102,133,156,189,199,203,555]


@get_time
def get_num(target_num, l1):
    if len(l1) == 0:
        print('不好意思没找到！')
        return
    else:
        mid_num = len(l1) // 2
        if target_num > l1[mid_num]:
            l1_right = l1[mid_num + 1:]
            print(l1_right)
            get_num(target_num, l1_right)
        elif target_num < l1[mid_num]:
            l1_left = l1[:mid_num]
            print(l1_left)
            get_num(target_num, l1_left)
        else:
            print('找到了%s' % target_num)
            return
get_num(102, l)  # 结果如下
'''
[12, 34, 56, 78, 90, 102]
[90, 102]
找到了102
0.0
0.0
0.0
'''