理论上要每天写一点东西。

1.数据结构和算法

1.1 输出文本中匹配的内容的行以及前几行

#!/usr/bin/env python

from collections import deque


def search(lines,pattern,history=5):
    previous_lines = deque(maxlen=history)
    for line in lines:
        if pattern in line:
            yield line,previous_lines
        previous_lines.append(line)
        
if __name__ == '__main__':
    with open('55555.txt') as f:
        for line,previous_lines in search(f, 'python', 3):
            for pline in previous_lines:
                print(pline,end='')
            print(line)
            print('-'*20)

1.2取N个最大和最小值

import heapq

list1 = [1,-3,55,-44,0]
print(heapq.nlargest(3, list1))
print(heapq.nsmallest(3, list1))

#当所要找的元素个数相对较小时，函数nlargest()和nsmallest()才是最合适的。
#如果要找的元素个数与集合本身差不多大的话，通常更快的方法是先对集合排序再切片。（sorted(list1)[:N] or sorted(list1)[-N:]）

print(min(list1))
print(max(list1))
#如果只查询最大或者最小的一个值，还是用min()和max()更快。

1.3 对字典的数据排序

prices = {
          'a':123,
          'b':456,
          'd':559,
          'f':865
          }

print(min(zip(prices.values(),prices.keys())))

(123, 'a')

#如果尝试在字典上执行常见的数据操作，将会发现它们只会处理键，而不是值。
#为了能对字典内容做些有用的计算，通常会利用zip()将字典的键和值反转过来。

1.4 在两个字典间处理异同

dict_a = {
          'x':1,
          'y':2,
          'z':3
          }
dict_b = {
          'a':1,
          'b':2,
          'y':3
          }

print(dict_a.keys() & dict_b.keys()) #a和b都有的键
print(dict_a.keys() - dict_b.keys()) #去掉a中有b的键
print(dict_a.items() - dict_b.items()) #去掉a中有b的键值的item。


c = {key:dict_a[key] for key in dict_a.keys() - ['z','x']}
print(c)

#结果：
{'y'}
{'x', 'z'}
{('z', 3), ('y', 2), ('x', 1)}
{'y': 2}

1.5 从序列中移除重复项且保持元素间顺序不变

如果无需保证元素间顺序不变，可以a = [1,21,2,2,1,3,5]，然后set(a)就可以去重。

如果要保证元素间顺序不变，见下：

a = [1,2,3,4,5,5,4,3,2,1]
#序列中的元素必须是可哈希（在生存周期内不可变）的
def deqeue(items):
    seen = set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)
print(list(deqeue(a)))

#结果：
[1, 2, 3, 4, 5]


#如果序列中的元素是不可哈希的，就得用下面的代码了，
a = [1,2,3,4,5,5,4,3,2,1]
b = [{'x':1,'y':2},{'x':1,'y':3},{'x':2,'y':2},{'x':1,'y':3},{'x':4,'y':3},]

def duqeue(items,key=None):
    seen = set()
    for item in items:
        val = item if key is None else key(item)
        if val not in seen:
            yield val
            seen.add(val)
            
print(list(duqeue(a)))
print(list(duqeue(b, key=lambda d:(d['x'],d['y']))))

#结果：
[1, 2, 3, 4, 5]
[(1, 2), (1, 3), (2, 2), (4, 3)]

1.12 找出序列中出现次数最多的元素

from collections import Counter
a = [1,2,3,4,5,5,4,3,2,1,1,1,1,2,3,3,4]

counters = Counter(a)
print(counters[4])
print(counters[1])
print(counters.most_common(3))

#结果：
3  #4出现了3次
5  #1出现了5次
[(1, 5), (3, 4), (2, 3)] #按出现次数从大到小前三位

 1.13 通过公共键对字典列表排序

from operator import itemgetter

rows = [
        {'fname':'Brian','lname':'fsaf','uid':432432},
        {'fname':'Zrian','lname':'ssaf','uid':132432},
        {'fname':'Crian','lname':'zsaf','uid':332432}        
        ]

rows_by_fname = sorted(rows, key=itemgetter('fname'))
rows_by_uid = sorted(rows, key=itemgetter('uid'))

print(rows_by_fname)
print(rows_by_uid)

#结果：
[{'uid': 432432, 'fname': 'Brian', 'lname': 'fsaf'}, {'uid': 332432, 'fname': 'Crian', 'lname': 'zsaf'}, {'uid': 132432, 'fname': 'Zrian', 'lname': 'ssaf'}]    #按fname的开始字母排序的
[{'uid': 132432, 'fname': 'Zrian', 'lname': 'ssaf'}, {'uid': 332432, 'fname': 'Crian', 'lname': 'zsaf'}, {'uid': 432432, 'fname': 'Brian', 'lname': 'fsaf'}]    #按uid的大小排序的

rows_by_fname_lambda = sorted(rows, key = lambda r:r['fname'])
rows_by_uid_lambda = sorted(rows, key = lambda r:(r['uid'],r['fname'])) ，利用lambda也能实现，只是效率不如用itemgetter高。

1.14 对不原生支持比较操作的对象排序

class User:
    def __init__(self,user_id):
        self.user_id = user_id
    def __repr__(self):
        return 'User({})'.format(self.user_id)

u = [User(17),User(27),User(3)]
print(sorted(u,key = lambda u:u.user_id))

#结果：
[User(3), User(17), User(27)]

直接排序User(17),User(27),User(3)是会报错的。

1.16 筛选序列中的元素

a = [1,-1,2,0,33,4,-22]
print([n for n in a if n > 0])
#这样可以做到，但是如果原始数据非常大的话，这么做可能会产生一个庞大的结果。如果这是你需要考虑的问题，那么可以使用生成器表达式通过迭代的方式产生筛选的结果。

pos = [n for n in a if n > 0]
for x in pos:
    print(x)

有时候以为生成器的语法太简单而不足以满足需求，可以自定义一个筛选函数，然后结合filter筛选，
b = [1,-1,2,0,33,4,-22,'fdsaf']
def val_filter(num):
    try:
        x = int(num)
        return True
    except ValueError:
        return False

ivals = list(filter(val_filter,b))
print(ivals)