04_11、常见的内置函数

内置函数详细分类：数学运算、类型装换、序列操作、对象操作、反射操作、变量操作、文件操作、交互操作、编译执行、装饰器

1、map 映射

　　1、语法结构

　　　　　　map(func, *iterables)
　　　　　　func是函数名，*iterables是可迭代对象

　　2、底层原理

　　　　　　foe循环

　　3、实例

# 要求：给列表l中的每一个元素平方，得到一个新列表
l = [1, 2, 3, 4, 5]
# map映射
map(lambda x: x ** 2, l)
# map语法结构map（函数名，可迭代对象）
# lambda语法结构 lambda(参数，返回值)
# lambda与map的结合使用

res = list(map(lambda x: x ** 2, l))
# map（）得出的是内存地址，list（map（））才是结果
print(res)

# 返回结果[1, 4, 9, 16, 25]

2、zip 拉链

　　实现两个或连个以上列表对应索引位置的一一结合

　　（1）传统实现方式

l1 = [1, 2, 3, 4, 5, 6]
l2 = ['ly', 'jason', 'tom', 'kevin', 'tony', 'Pony']
# 先定义一个新变量列表，用于存储结果
list_1 = []
for i in range(len(l1)):  # len(l1)==6,range(6)结果是[0,1,2,3,4,5],顾头不顾尾
    list_1.append((l1[i], l2[i]))  # 注意.append()内只能有一个参数，所以必须把两个括起来
print(list_1)
# 返回结果[(1, 'ly'), (2, 'jason'), (3, 'tom'), (4, 'kevin'), (5, 'tony'), (6, 'Pony')]

　　（2）zip实现方式

l1 = [1, 2, 3, 4, 5, 6]
l2 = ['ly', 'jason', 'tom', 'kevin', 'tony', 'Pony']

zip(l1, l2)
res = list(zip(l1, l2))
print(res)
# 返回结果[(1, 'ly'), (2, 'jason'), (3, 'tom'), (4, 'kevin'), (5, 'tony'), (6, 'Pony')]

　　（3）zip实现两个以上列表的对应

　　注意：如果列表长度不同，以最短的一个输出

l1 = [1, 2, 3, 4, 5, 6]
l2 = ['ly', 'jason', 'tom', 'kevin', 'tony', 'Pony']
l3 = ['a', 'v', 'b', 'c', 'd']
l4 = [111, 222, 333, 444]

zip(l1, l2, l3, l4)
res = list(zip(l1, l2, l3, l4))
print(res)
# 返回结果[(1, 'ly', 'a', 111), (2, 'jason', 'v', 222), (3, 'tom', 'b', 333), (4, 'kevin', 'c', 444)]

3、max和min

　　（1）传统实现方式

l = [1, 2, 3, 4, 66, 77, 8, 99, ]
l.sort()  # 升序
# l.sort(reverse=True)  # 降序
print(l[-1])  # 通过索引-1求最大值
print(l[len(l) - 1])  # 通过len列表长度-1取最大值
# 结果都是99

　　（2）max和min实现方式

# 列表
l = [1, 2, 3, 4, 66, 77, 8, 99, ]
l4 = [111,222,333]

print(max(l))
# 结果是99
print(min(l))
# 结果都是1

print(max(l,l4))
# 结果都是[111, 222, 333]
print(min(l,l4))
# 结果都是[1, 2, 3, 4, 66, 77, 8, 99]
# 注意：两个列表比较比的是列表的第一个索引值，如果相同继续比较下一位

 

# 字典
d = {
    'ly': 9999999,
    'jason': 1000,
    'kevin': 2000,
    'tom': 20
}

'''
    字典暴露的是k值，
    按照ASCII码对应的十进制比较
    0:48   
    A:65
    a:97
'''

# max(d, key=None)  # 底层也是for循环
# 其中d是可迭代对象，key是比较的值，没写默认为None
# max函数返回什么值就按照什么值进行比较，所以字典的返回结果还是字段的k
print(max(d, key=lambda key: d[key]))  # 底层也是for循环
# 返回值为ly
print(min(d, key=lambda key: d[key]))  # 底层也是for循环
# 返回值为tom

4、filter 过滤

# 要求取出列表l中大于30的元素
l = [1, 2, 3, 4, 66, 77, 8, 99, ]

print(list(filter(lambda x: x > 30, l, )))
# 返回值为[66, 77, 99]