Python - 进阶技能：列表、字典、集合的处理

来自B站

 

在列表，字典，集合中根据条件筛选数据

示例：

from random import randint

# 根据条件筛选数据

lst = [23,56,67,89,0,98,45,67,46,65]

# 列表解析  -- 推荐
new_lst1 = [n for n in lst if n >= 60]
print(new_lst1)

# filter()函数解析
new_lst2 = filter(lambda x: x >=60 , lst)
print(list(new_lst2))

# 用字典解析创建数据
dic = {'Student%d' % i: randint(0,100) for i in range(1,20)}
print(dic)

# 字典解析筛选数据 - 推荐
new_dict1 = {k:v for k,v in dic.items() if v >= 60}
print(new_dict1)

# filter()函数解析字典
new_dict2 = filter(lambda item: item[1] >= 60, dic.items())
print(dict(new_dict2))

# 集合解析 - 推荐
s = {randint(0,20) for _ in range(20)}
new_s = {x for x in s if x % 3 == 0}
print(new_s)

 

为元组中的每个元素命令，提高程序可读性。元组比其他类型的优点：节省空间

示例：

# 方法1: 枚举
from enum import IntEnum

s = ('Su',12,'male','123@qq.com')

class StudentEnum(IntEnum):
    NAME = 0
    AGE = 1
    SEX = 2
    EMAIL = 3

print(s[StudentEnum.NAME])    # 输出 Su
print(s[StudentEnum.AGE])     # 输出 12


# 方法2： 使用标准库中collections.nametuple 替代内置tuple  - 推荐
from collections import namedtuple
Student = namedtuple('Student',['name','age','sex','email'])
s2 = Student('Su',12,'male','123@qq.com')
print(s2)     # 输出 Student(name='Su', age=12, sex='male', email='123@qq.com')
print(s2[1])    # 输出 12
print(s2.age)   # 输出 12

 

根据字典中值的大小，对字典中的项排序

示例

# 将字典中的各项转换成元组，使用内置函数sorted排序

# 方法1：将字典中的项转化为（值，键）元组。（列表解析或zip)
from random import randint

old_dict = {k: randint(0,100) for k in 'abcdefghijkl'}
print(old_dict)   # 输出字典
# 列表解析 转成元组
dict_to_tuple = [(v,k) for k,v in old_dict.items()]
# zip函数 转成元组
# dict_to_tuple = list(zip(old_dict.values(),old_dict.keys()))
print(dict_to_tuple)   # 输出列表，元素是元组
print(sorted(dict_to_tuple))   # 升序  输出列表，元素是元组
print(sorted(dict_to_tuple,reverse=True))  # 倒序   输出列表，元素是元组

# 方法2：传递sorted函数的key参数
p = sorted(old_dict.items(),key=lambda item: item[1],reverse=True)
print(p)   # 倒序   输出列表，元素是元组，key在前 value在后的元组
p_num = list(enumerate(p,1))   # 第2个参数1是指从1开始算
print(p_num)   # 输出 [(1, ('i', 94)), (2, ('l', 81)), (3, ('g', 80))。。。。=》 顺序,(key, value)
d = {k:v for i, (k,v) in p_num}
print(d)   #输出倒序的字典

 

统计序列中元素的频度

示例：对数字进行统计，并取最大前几位

from random import randint

data = [randint(0,5) for _ in range(10)]
print(data)

# 方法1：将序列转换为字典{元素：频度}，根据字典中的值排序
d = dict.fromkeys(data,0)   # data列表的元素作key,0为设置的value
print(d)

for x in data:
    d[x] += 1   # 循环列表，元素每出现一次，累加一次到字典上
print(d)

# 以value作排序，取最高前三个
# res = sorted([(v,k) for k,v in d.items()], reverse=True)[:3]   # 列表解析
res = sorted(((v,k) for k,v in d.items()), reverse=True)[:3]   # 生成解析，比列表解析更节省空间
print(res)

# 当列表数据量很大，但只查出现次数最大的几个时，上面这种方法就有缺点了：浪费
# 推荐heapq模块方法查找最大几个或最小几个元素
import heapq
res = heapq.nlargest(3, ((v,k) for k,v in d.items()))
print(res)

# 方法2：使用标准库collections中的Counter对象。  ---   推荐
from collections import Counter
c = Counter(data)
res = c.most_common(3)   # 查找前三个
print(res)

示例：对文件内容字符串出现的次数作统计

import re
from collections import Counter

# 读取文件
with open('1.txt','r') as f:
    allData = f.read()   # 读出str类型

world_lst = re.split('\s+',allData)  # 空格、换行...进行分割
c = Counter(world_lst)
res = c.most_common(5)   # 字符串出现次数最高的前5个
print(res)

 

在多个字典中寻找公共键

示例：方法1，和方法3都可用

from random import randint

dict1 = {k:randint(0,5) for k in 'ABCDEFG'}
dict2 = {k:randint(0,5) for k in 'ABCFG'}
dict3 = {k:randint(0,5) for k in 'ABCDE'}
dict4 = {k:randint(0,5) for k in 'ACDEFG'}
all_dict = [dict1, dict2, dict3, dict4]

# 方法1
res = [k for k in all_dict[0] if all(map(lambda d: k in d, all_dict[1:]))]
print(res)


from functools import reduce
# 利用集合（set）的交集操作

# 方法2
# 使用字典的key()方法，得到一个字典keys的集合
s1 = dict1.keys()
s2 = dict2.keys()
s3 = dict3.keys()
s4 = dict4.keys()
print(s1 & s2 & s3 & s4)   # 如果有很多字典，这方法就太繁琐了
# 使用map函数，得到每个字典keys的集合
s = list(map(dict.keys,all_dict))   # 得到的是每个字典的key，未集合
print(s)

# 方法3
# 使用reduce函数，取所有字典的keys集合的交集
res = reduce(lambda a, b: a & b, map(dict.keys,all_dict))  # 得到每个字典key交集
print(res)

 

让字典保持有序

示例：OrderedDict()函数，按写入顺序排序的字典；查找key在字典的位置；字典某些位置的成员key是什么

from collections import OrderedDict

od = OrderedDict()  #一个字典，自动按照写入顺序排序
# od['s'] = 2
# od['w'] = 1
# od['p'] = 7
# print(od.keys())

from random import shuffle
players = list('abcdefg')
shuffle(players)    # 打乱列表顺序
print(players)

for i, p in enumerate(players, 1):  # 从1开始，给players元素带个数字
    od[p] = i
print(od)

def query_by_name(d,name):   # 某个key在字典的第几个成员
    return d[name]

print(query_by_name(od,'c'))

from itertools import islice

def query_by_position(d,start_position, end_position=None):
    start_position -= 1
    if end_position is None:
        end_position = start_position + 1
    return list(islice(d, start_position, end_position))

print(query_by_position(od, 3))     # 字典第3个成员key是
print(query_by_position(od, 3, 6))    # 字典第3~6的成员key是

 

用户的历史记录功能（最多n条）

示例：保存在磁盘；保存在本地

from collections import deque

# deque() 双端队列
dq = deque([], 5)  # 第一个参数是队列初始化，参数5是容量，不填则容量无限大
# dq.appendleft()  # 左端入队， 要保持同端入队
dq.append(2)  # 右端入队
dq.append(3)
dq.append(4)
dq.append(5)
dq.append(1)
dq.append(6)
print(list(dq))   # 输出[3, 4, 5, 1, 6]。当容量满了时，继续入队，则最开始入队的就会从左端出队

# 上面的存入是在磁盘中，以下为保存在本地文件
import pickle

pickle.dump(dq, open('saveLocal.pkl', 'wb'))   # 二进制，写入
res = pickle.load(open('saveLocal.pkl', 'rb'))   # 读取
print(res)