1 列表字典集合过滤数据

均有两种方法，建议是用列表解析的方法。

列表

方法一：列表解析法
image.png
方法二：filter函数
image.png
注意在python3中，将返回一个迭代器，next可以消耗迭代器元素。

字典

方法一：列表解析法
image.png
方法二：filter函数
image.png

集合

image.png

2 如何为元组命名，提高程序可读性

由于元组要比字典节省空间很多，因此固定格式的文件通常用元组保存，但访问时，我们只能使用索引方式访问，大量索引降低了程序的可读性。为了可读性，需要进行转换。推荐方法二

方法一：定义数值常量或枚举类型

数值常量：

image.png

枚举类型
image.png
枚举类型中对象就是数值。

方法二：使用collections.namedtuple替代内置的tuple

image.png
注意这里s2看起来像是类的对象，实际是元组，但是可以像访问对象一样访问其对应名称的值。

3 如何根据字典值得大小，对字典中得项进行排序

推荐方案2
例如：{“Liming”93,”lisiji”:22,”wangfei”:73}，根据后面数字进行排名。
造数据：

  1. from random import randint
  2. d = {k: randint(50,100) for k in 'abcdefg'}

方案1：将字典中得项转化为（值，键）元组，（列表解析或zip）

  1. l = [(v,k) for k,v in d.items()]    # 和这个等价   list(zip(d.values(), d.keys()))
  2. l   # [(96, 'a'), (81, 'b'), (55, 'c'), (78, 'd'), (79, 'e'), (73, 'f'), (70, 'g')]
  1. sorted(l, reverse=True) # [(96, 'a'), (81, 'b'), (79, 'e'), (78, 'd'), (73, 'f'), (70, 'g'), (55, 'c')]

方案2：传递sorted函数的key参数

  1. sorted(d.items(), key=lambda item:item[1],reverse=True) #[('a', 96), ('b', 81), ('e', 79), ('d', 78), ('f', 73), ('g', 70), ('c', 55)]

加排序，注意不同的方式表达

  1. list(enumerate(p, 1))
  2. #[(1, ('a', 96)),
  3. # (2, ('b', 81)),
  4. # (3, ('e', 79)),
  5. # (4, ('d', 78)),
  6. # (5, ('f', 73)),
  7. # (6, ('g', 70)),
  8. # (7, ('c', 55))]
  10. {k:(i,v) for i,(k,v) in enumerate(p, 1)}
  11. #{'a': (1, 96),
  12. # 'b': (2, 81),
  13. # 'e': (3, 79),
  14. # 'd': (4, 78),
  15. # 'f': (5, 73),
  16. # 'g': (6, 70),
  17. # 'c': (7, 55)}

4 如何统计序列中元素的频度

任务：例如统计出现次数最高的，比如统计英文单词数量。
建议使用下面的方案2

方案1：将序列转换为字典{元素：频度}，根据值排序

  1. data = [randint(0,20) for _ in range(40)]
  2. d = dict.fromkeys(data, 0) # 根据所有值，得到对应的key
  3. # {19: 0,
  4. #  4: 0,
  5. #  5: 0,
  6. #  3: 0,
  7. #  6: 0,
  8. #  0: 0,
  9. #  15: 0,
  10. #  8: 0,
  11. #  2: 0,
  12. #  18: 0,
  13. #  1: 0,
  14. #  9: 0,
  15. #  12: 0,
  16. #  7: 0,
  17. #  20: 0,
  18. #  17: 0,
  19. #  10: 0}
  1. for x in data:
  2.     d[x] +=1
  3. sorted(((v,k) for k,v in d.items()),reverse=True)[:3] # [(5, 6), (4, 15), (4, 3)]   这里内部使用元组，比list节省空间
  1. import heapq
  2. # 也有heapq.nsmallest 函数可以使用
  3. heapq.nlargest(3,((v,k) for k,v in d.items()))  # [(6, 5), (3, 4), (15, 4)]

方案2：使用标准库collections中的Counter对象

  1. data = [randint(0,20) for _ in range(40)]
  2. from collections import Counter
  3. c = Counter(data)
  4. c.most_common(3)     #  [(6, 5), (3, 4), (15, 4)]

5 pickle 存取数据

  1. from collections import deque
  2. q = deque([],4)
  3. q.append(3)
  4. q.append(32)
  5. q.append(1)
  6. q  #deque([3, 32, 1])
  8. import pickle
  9. pickle.dump(q, open('save.pkl', 'wb')) # pickle必须以二进制
  11. q2 = pickle.load(open('save.pkl','rb'))
  12. q2  #deque([3, 32, 1])