1. enumerate枚举函数

enumerate()枚举函数: 为可迭代对象分配索引序列, 组成一个列举对象.使用方法: 
enumerate(可迭代对象, start=0) 返回一个列举对象的地址.
下标, 默认从0开始, 通过start参数表示序列下标的起始位置, 默认不写start=0.通常搭配for循环使用, 每次取出一个元组, 元组的第一个值是下标, 第二个值是可迭代对象的元素.

print(enumerate([1, 2, 3]))  # <enumerate object at 0x000002E3285472C0>
# 可迭代对象可以使用list函数转为列表类型.
print(list(enumerate([1, 2, 3])))  # [(0, 1), (1, 2), (2, 3)]
# 通过start参数修改下标.
print(list(enumerate([1, 2, 3], start=1)))  # [(1, 1), (2, 2), (3, 3)]for i in enumerate([1, 2, 3]):print(i)"""(0, 1)(1, 2)(2, 3)"""# 设置两个迭代变量, 遍历取出的元组会以解包赋值的方式将元素分别赋值给x与y.
for x, y in enumerate([1, 2, 3]):print(x, y)"""0 11 22 3"""

# 快速创造字典
list1 = ['name', 'age', 'hobby']res1 = {k: v for k, v in enumerate(list1)}  
print(res1)  # {0: 'name', 1: 'age', 2: 'hobby'}res2 = {'k'+str(k): v for k, v in enumerate(list1)} 
print(res2)  # {'k0': 'name', 'k1': 'age', 'k2': 'hobby'}res3 = {'k' + str(k): v for k, v in enumerate(list1, start=1)} 
print(res3)  # {'k1': 'name', 'k2': 'age', 'k3': 'hobby'}

# 搭配字典生成式
list1 = ['name', 'age', 'hobby']
# 搭配if语句使用, 对k添加额外条件, k为0跳过.
res = {'k' + str(k): v for k, v in enumerate(list1) if k != 0}
print(res)  # {'k1': 'age', 'k2': 'hobby'}

2. map映射函数

在Python3中为了减少内存的使用, map(), zip(), filter()返回的是一个可迭代对象.
Python2中直接返回列表.

map()映射函数: 遍历可迭代对象中每个元素, 将元素交给另一个函数进行处理, 将处理的结果返回.
格式: 
map(function, iterable)  
function参数: 函数名称, 通过该函数对后续参数iterable进行处理
iterable参数: 可迭代对象, 如: 字符串, 列表, 字典, 元组, 集合等.

#　将纯数字字符装换为整型.
list1 = ['0', '1', '2', '3', '4']# 将list1的每个元素交给int函数做处理, 并将处理的结果返回.
res = map(int, list1)# 使用list()转换成一个列表展示下.
print(list(res))  # [0, 1, 2, 3, 4]

# 搭配匿名函数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]# list1中的每个元素依次作为参数传递给匿名函数处理.
print(list(map(lambda x: x ** 2, list1)))  # [1, 4, 9, 16, 25, 36, 49, 64, 81]

3. zip拉链函数

zip函数: 将可迭代对象的元素按序列的排序为一组打包成元组, 返回列表套元组的格式.
格式: 
zip(iterable1, iterable2, ...)
iterable: 可迭代对象, 可以有多个, 多个可迭代对象中, 以元素最短的对象为准打包, 因次被称为拉链函数.

list1 = ['k1', 'k2', 'k3']
list2 = ['v1', 'v2', 'v3', 'v4']
list3 = ['x1', 'x2', 'x3', 'x4']res = zip(list1, list2, list3)
print(list(res))
# [('k1', 'v1', 'x1'), ('k2', 'v2', 'x2'), ('k3', 'v3', 'x3')]

当两个可迭代对象拉链操作后, 可以直接dict()转为字典, 键一定是不可变类型的值才行.

# 快速生成字典
list1 = ['k' + str(i) for i in range(1, 6)]  # ['k1', 'k2', 'k3', 'k4', 'k5']
list2 = ['v' + str(i) for i in range(1, 7)]  # ['v1', 'v2', 'v3', 'v4', 'v5', 'v6']res = zip(list1, list2)
print(list(res))  # [('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3'), ('k4', 'v4'), ('k5', 'v5')]print(dict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3'), ('k4', 'v4'), ('k5', 'v5')]))
# {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4', 'k5': 'v5'}

4. max,min比较函数

max()函数: 获得给定的可迭代对象中的最大值.
如果是字符比较按Unicode所对应的10进制逐位比较, 只需要比出一个大小就结束比较.格式: 
max(*args, key=None)
args参数: 接收一个参数时, 对迭代元素进行比较, 多个位置参数, 多参数进行比较, 不同类型无法比较.
key参数: 辅助max()函数找到最大元素, 对比较的对象进行一些处理, 以达到对对象进行特定规则的比较.
* key为一个方法或函数时必须省略掉括号, 是匿名函数时可以使用括号.

min函数: 获得给定的可迭代对象中的最小值.

4.1 对象比较

list1 = ['k1', 'k2', 'k3', 'k4', 'k5']
list2 = ['v1']# 比较对象的大小, 不同类型无法比较.
print(max(list1, list2))  # ['v1']   

4.2 列表相关

1. 获取列表中的最大值

list1 = ['k1', 'k2', 'k3', 'k4', 'k5']
list2 = ['v1']# 比较列表内元素大小
print(max(list1))  

2. 获取列表中的最大数值

list1 = ['11', '333', '222', '88']
print(max(list1, key=lambda x: int(x)))  # 333

3. 获取列表中指定索引的最大值

list1 = [(1, 'a'), (2, 'b'), (3, 'c')]
print(max(list1, key=lambda x: x[1]))  # (3, 'c')

4. 获取列表中的最大的绝对值

list1 = ['11', '333', '222', '88', '-555']
print(max(list1, key=lambda x: abs(int(x))))  # -555

4.3 字典相关

1. 获取字典中key的最大值

dic = {'k1': 3000,'k2': 2000,'k3': 1000,'k4': 600,'k5': 700}print(max(dic))  # k5
print(max(dic.keys()))  # k5

2. 获取字典中最大value对应的key值

dic = {'k1': 3000,'k2': 2000,'k3': 1000,'k4': 600,'k5': 700}# key为一个方法或函数时必须省略掉括号.
print(max(dic, key=dic.get))  # k1# 设置key参数时, 将遍历的元素交给key的表达式处理后在比较, 返回比较结果的key值.
print(max(dic, key=lambda key: dic[key]))  # k1

# 值一样大的情况
dic = {'k1': 2000,'k2': 3000,'k3': 1000,'k4': 3000,'k5': 700}print(max(dic, key=lambda key: dic[key]))  # k2

k1 与 k2 比较 k2大保留. 
k2 与 k3 比较 k2大保留.
k2 与 k4 比较 k2不大于k4, k2保留.猜测内部使用大于符号比较: x if x > y else y

3. 获取字典中最大value的值

dic = {'k1': 3000,'k2': 2000,'k3': 1000,'k4': 600,'k5': 700}print(max(dic.values()))  # 3000

4.4 字符串相关

1. 获取字符串中最大的字符

str1 = 'asdas55'
print(max(str1))  # s

2. 获取出现次数最多的字符

str1 = 'asdas55'
print(max(str1, key=str1.count))  # a
# 遍历对象的元素, 就传递给匿名函数的参数.
print(max(str1, key=lambda i: str1.count(i)))  # a

3. 获取句子中的最长单词

# 符号分开不然就和单词算在一起, 单词多出一个字符.
str1 = "Life is short , I use Python !"  # 字符串按空格切分得到一个列表,
print(max(str1.split(), key=len))  # Python

5. filter过滤函数

filter()函数: 用于过滤序列, 过滤不符合条件的元素, 返回由符合条件的元素组成的新列表.
格式:
filter(function, iterable)
function参数: 处理迭代对象元素的函数. 
iterable参数: 可迭代对象.迭代对象的元素元素每个作为参数传递给函数进行判断, 将返回值为True的元素放到新列表中.

# 遍历列表, 将元素大于3的元素保存到新的列表, 遍历完毕后加新列表返回.
res = filter(lambda x: x > 3, [1, 2, 3, 4, 5, 6, 7, 8])
print(list(res))  # [4, 5, 6, 7, 8]

# x % 2 在这等同与 if x % 2 结果为0就被过滤
res = filter(lambda x: x % 2, range(1, 101))  
print(list(res))  # 1 - 100 中的奇数res = filter(lambda x: not x % 2, range(1, 101))  
print(list(res))  # 1 - 100 中的偶数

6. reduce累加函数

seduce()函数: 会对参数序列中元素进行累加.
先从可迭代对象中取两个元素作为在函数中参数, 函数得到的结果与下次遍历取出的值进行计算···

Python3.x reduce()已经被移到functools模块中.
form functools import reduce
seduce(function, iterable, initializer)
function参数: 处理函数, 需要接收两个参数. 
iterable参数: 可迭代对象.
initializer参数:  可选, 初始参数.

from functools import reduceres = reduce(lambda x, y: x + y, [1, 2, 3, 5, 5])
print(res)  # 16

from functools import reduce# 
res = reduce(lambda x, y: x + y, [1, 2, 3, 5, 5], 3)  # 基础值
print(res)  # 19

7. 练习

1. a.txt文件内容如下, 标题为: 姓名, 性别, 年纪, 薪资.
kid male 18 3000
qq male 19 30000
qaq female 18 20000
qz female 20 10000要求:
1. 从文件中取出每一条记录放入列表中.列表的每个元素都是{'name':'kid','gender':'male','age':18,'salary':3000} 的形式.
2. 根据1得到的列表, 取出所有人的薪资之和.
3. 根据1得到的列表, 取出所有的男人的名字.
4. 根据1得到的列表, 将每个人的信息中的名字映射成首字母大写的形式.
5. 根据1得到的列表, 过滤掉名字以a开头的人的信息.
6. 根据1得到的列表, 取出薪资最高的人的信息.
7. 根据1得到的列表, 取出最年轻的人的信息.
8. 根据1得到的列表, 给用户名加上_vip的后缀, 如 kid_vip.
9. 求文件a.txt中最长的行的长度(长度按字符个数算, 需要使用max函数).
10.求文件a.txt中总共包含的字符个数,

with open('a.txt', mode='rt', encoding='utf8') as rf:user_info = rf.readlines()print(user_info)
# ['kid male 18 3000\n', 'qq male 19 30000\n', 'qaq female 18 20000\n', 'qz female 20 10000\n']# 去除\n 在切分
user_info = [i.strip('\n').split() for i in user_info]
print(user_info)
# [['kid', 'male', '18', '3000'], ['qq', 'male', '19', '30000'],
# ['qaq', 'female', '18', '20000'], ['qz', 'female', '20', '10000']]# 字典的键
dic_key_list = ['name', 'gender', 'age', 'salary']# zip
user_info = [ dict(zip(dic_key_list, i)) for i in user_info]
print(user_info)
"""
[
{'name': 'kid', 'gender': 'male', 'age': '18', 'salary': '3000'},{'name': 'qq', 'gender': 'male', 'age': '19', 'salary': '30000'}, {'name': 'qaq', 'gender': 'female', 'age': '18', 'salary': '20000'}, {'name': 'qz', 'gender': 'female', 'age': '20', 'salary': '10000'}
]
"""# 2. 根据1得到的列表, 取出所有人的薪资之和.
saraly_list = [int(i.get('salary'))  for i in user_info]
print(saraly_list)
# [3000, 30000, 20000, 10000] 不要直接sum 这是练习from functools import reducecount = reduce(lambda x, y : x + y, saraly_list)
print(count)  # 63000# 3.根据1得到的列表, 取出所有的男孩子的名字.
male_list = [i.get('name') for i in user_info if i.get('gender') == 'male']
print(male_list)# 4.根据1得到的列表,将每个人的信息中的名字映射成首字母大写的形式
name_list = [i.get('name').capitalize() for i in user_info]
print(name_list)# 5.根据1得到的列表,过滤掉名字以q开头的人的信息
filter_list = [i for i in user_info if not i.get('name').startswith('q')]
print(filter_list)# 6. 根据1得到的列表,取出薪资最高的人的信息
print(max(user_info, key=lambda dic: dic.get('salary')))
# {'name': 'qq', 'gender': 'male', 'age': '19', 'salary': '30000'}
# 把 user_info 一个个元素传进 匿名函数中 匿名函数把salary的值返回去做比较# 7.根据1得到的列表,取出最年轻的人的信息
print(min(user_info, key=lambda dic: dic.get('age')))  # 两个人年纪一样大的 显示第一个小的
# {'name': 'kid', 'gender': 'male', 'age': '18', 'salary': '3000'}# 8.根据1得到的列表,给用户名加上_vip的后缀, 如 kid_vip
[dic.update({'name': dic['name'] + '_vip'}) for dic in user_info]
# 直接修改可变类型内的值
print(user_info)

# 9. 求文件a.txt中最长的行的长度（长度按字符个数算, 需要使用max函数）
with open('a.txt', mode='rt', encoding='utf8') as rf:user_info = rf.readlines()print(user_info)
# 去除\n , 每一行都有\n 去不去都不所谓
user_info = [i.strip('\n') for i in user_info]print(user_info)
# ['kid male 18 3000', 'qq male 19 30000', 'qaq female 18 20000', 'qz female 20 10000']
dic = dict(enumerate(user_info, start=1))
print(dic)
# {1: 'kid male 18 3000', 2: 'qq male 19 30000', 3: 'qaq female 18 20000', 4: 'qz female 20 10000'}
line = max(dic, key=lambda key: len(dic[key]))
print(f'第{line}行的字符数最多')  # 3   第三行

# 10.求文件a.txt中总共包含的字符个数
with open('a.txt', mode='rt', encoding='utf8') as rf:num = [len(i) for i in rf ]print(num)
from functools import reduce
count = reduce(lambda x, y : x+y, num, 0)
print(count)