01：数据结构和算法

*** ：“_” 占位变量 (须保证你选用的那些占位变量名在其他地方没被使用到,一般选用 "_")

　　data = [ ‘ACME‘, 50, 91.1, (2012, 12, 21) ]

　　 _, shares, price, _ = data

*** ： 解压变量 *para

　　*trailing, current = [10, 8, 7, 1, 9, 5, 10, 3]#该方法需要保证current能获取到一个值（python3适用）

*** ： collections python 容器数据类型

　　----Counter是对字典的型的补充，它继承了dict类，用于追踪迭代项出现次数。

　　　　para = [‘home‘, ‘dir‘, ‘cmd‘, ‘home‘, ‘list‘,‘dir‘]

　　　　res = Counter（para） 　　#Counter({‘home‘: 2, ‘dir‘: 2, ‘cmd‘: 1, ‘list‘: 1})
　　　　res 具有字典的一切特效，同时还具有特别的特性

　　　　list(res.elements()) 　　#[‘home‘, ‘home‘, ‘cmd‘, ‘list‘, ‘dir‘, ‘dir‘]
　　　　res.most_common(3)　　# [(‘home‘, 2), (‘dir‘, 2), (‘cmd‘, 1)]

　　　　new = Counter([‘home‘])　　　

　　　　res.substract(new)#同res - new。　　　　#结果Counter({‘dir‘: 2, ‘home‘: 1, ‘cmd‘: 1, ‘list‘: 1})

　　----OrderedDict 能够记录字典元素插入的顺序，常常和排序函数一起使用来生成一个排序的字典。（）

　　　　res = {‘banana’:3,’apple’:4,’pear’:1,’orange’:2}

　　　　OrderedDict(sorted(d.items(),key = lambda t:t[0]))#字典安装先后生成顺序

　　　　
　　----defaultdict属于内建函数dict的一个子类，python自动的为它的键赋了一个初始化值

　　　　dic = defaultdict(int) #表示用一个int()函数作为参数出给defaultdict，我们不带参数调用int()，int()就会返回一个0值

　　　dic[‘value‘] += 1#不会报错

　---- ChainMap  接受多个字典并将它们在逻辑上变为一个字典。（并不是真正合并成一个字典）　　　c = ChainMap(a,b)　　　两个字典中执行查找操作是：先从 a 中找，如果找不到再在 b 中找。

　---- deque　　 deque是双端队列，可以从两端塞元素进去，也可以从两端取元素;  deque是线程安全的，可以用来做多线程的共享资源　　　res = deque([1,2,3,2,4])　　　#双端操作，同列表。append/appendleft, extend/extendleft(其实如同一个元素使用append或者appendleft),pop/popleft,remove/reverse　　　rotate :　　#res.rotate(-2)　　从右往左旋转 此时 res = deque([3,2,4,1,2])　　　　　　res = deque([1,2,3,4,5,6,7], maxlen=4) #res = deque([4,5,6,7])　　#表示定长为4的队列

　---- namedtuple 命名元组命。名元组另一个用途就是作为字典的替代　　　如果你需要构建一个非常大的包含字典的数据结构，那么使用命名元组会更加高效。 但是需要注意的是，不像字典那样，一个命名元组是不可更改的。　　　如果你真的需要改变然后的属性，那么可以使用命名元组实例的 _replace() 方法， 它会创建一个全新的命名元组并将对应的字段用新的值取代。　　　如果你的目标是定义一个需要更新很多实例属性的高效数据结构，这时候你应该考虑定义一个包含 __slots__ 方法的类　　　person = namedtuple(‘P‘, ‘name age gender‘)或者 person = namedtuple(‘P‘, [‘name‘, ‘age‘, ‘sex‘])　　　obj = person(name = ‘holen‘, age = 25, sex = ‘male‘)或者obj = person(‘holen‘, 25, ‘male‘)#类似python种对象的使用　　　obj = obj._replace(age=75)#改变命名元组的值　　　使用namedtuple时候，不能使用关键字。同时，字串或者列表的值不能重复。　　　可以使用如下的保证：　　　person = namedtuple(‘P‘, ‘name age gender age‘, rename=True)　　　此时查看person._fields  # name, age, gender, _3   _3表示索引位置为3的元素已经重复

*** ：  heapq 堆数据结构　　堆数据结构最重要的特征是 iterable[0] 永远是最小的元素。　　 ---- heapq.nlargest(n, iterable[, key])/heapq.nsmallest(n, iterable[, key])　　　　(从迭代器对象iterable中返回前n个最大/小的元素列表，key用于匹配是字典对象的iterable，用于更复杂的数据结构中。)　　　　如果n的大小和集合大小接近的时候，效率不如sort.　　----  heapq.heapify(iterable)　　　　　　　　 #将iterable转换成堆. iterable 为定义的堆，无返回值。　　---- headpq.pop(iterable)　　　　　　　　　　 #先将第一个元素弹出来，然后用下一个最小的元素来取代被弹出元素　　---- heapq.heappush(iterable,item) 　　　　 #iterable为定义堆，item 增加的元素.　　---- heapq.heapreplace(iterable, item)     #删除最小元素值，添加新的元素值　　---- heapq.heappushpop(iterable, item)     #首判断添加元素值与堆的第一个元素值对比，如果大于则删除最小元素，然后添加新的元素值，否则不更改堆　　---- heapq.merge(iterable, iterable1)      #将多个堆合并,返回一个合并后的迭代

　　---- izip, imap, islice, tee　　

import heapq
#优先队列
#在上面代码中，队列包含了一个 (-priority, index, item) 的元组。 优先级为负数的目的是使得元素按照优先级从高到低排序。 这个跟普通的按优先级从低到高排序的堆排序恰巧相反。
#index 变量的作用是保证同等优先级元素的正确排序。 通过保存一个不断增加的 index 下标变量，可以确保元素按照它们插入的顺序排序。 而且， index 变量也在相同优先级元素比较的时候起到重要作用。

class PriorityQueue:
    def __init__(self):
        self._queue = []
        self._index = 0

    def push(self, item, priority):
        heapq.heappush(self._queue, (-priority, self._index, item))
        self._index += 1

    def pop(self):
        return heapq.heappop(self._queue)[-1]

*** ：  列表去重（保持原来顺序）

＃１
def dedupe(items):
    seen = set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)

a = [1, 5, 2, 1, 9, 1, 5, 10]
list(dedupe(a)) #[1, 5, 2, 9, 10]

＃２
OrderedDict.fromkeys(a).keys()

＃３
seen = set()
 seen_add = seen.add
[x for x in a if not (x in seen or seen_add(x))]

*** ：  slice 切片对象　　---内置的 slice() 函数创建了一个切片对象，可以被用在任何切片允许使用的地方。　　　　一个切片对象a，你可以分别调用它的 a.start , a.stop , a.step 属性　　　　a = [1,2,3,4,5,6,7] 　　　　s = slice(3,50)　　　　a[s] #同a[3:50]　　　　s.indices(len(a)) #-->所有值都会被合适的缩小以满足边界限制返回ｓｌｉｃｅ(3, 7, 1)该方法将它映射到一个确定大小的序列上， 返回一个三元组 (start, stop, step)

*** ：  根据某个或某几个迭代项的字段来排序这个迭代　　　---operator 模块的 itemgetter　　　　ｒｅｓ = sorted(rows, key=itemgetter(value[,value1]))# 如果迭代项是元组或者列表，ｖａｌｕｅ填索引，如果迭代项是字典，ｖａｌｕｅ填键值。

*** ： itertools模块　　---- chain(iter1, iter2, ..., iterN)：创建一个新迭代器来将所有的迭代器链接起来，返回从iter1持续到iterN的迭代器　　---- chain.from_iterable(iterables): 一个备用链构造函数，其中的iterables是一个迭代变量，生成迭代序列　　　　　　a = [[1, 2], [3, 4], [5, 6]]　　　　　　list(itertools.chain.from_iterable(a))　　 #[1, 2, 3, 4, 5, 6]　　---- combinations(iterable, r):　　#组合　　---- permutations(iterable [,r]): 　　#排列　　---- count([n]):创建一个迭代器，生成从n开始的连续整数，如果忽略n，则从0开始计算　　　　----cycle(iterable):创建一个迭代器，对iterable中的元素反复执行循环操作，内部会生成iterable中的元素的一个副本，此副本用于返回循环中的重复项。

　　---- tee(iterable [, n]): 从 iterable创建n个独立的迭代器，创建的迭代器以n元组的形式返回，n的默认值为2，此函数适用于任何可迭代的对象，但是，为了克隆原始迭代器，生成的项会被缓存，并在所有新创建的迭代器中使用，一定要注意，不要在调用tee()之后使用原始迭代器iterable，否则缓存机制可能无法正确工作。　　---- dropwhile(predicate, iterable):函数predicate(item)为True，就丢弃iterable中的项，如果predicate返回False，就会生成iterable中的项和所有后续项。

　　---- takewhile(predicate [, iterable]): 生成iterable中predicate(item)为True的项，只要predicate计算为False，迭代就会立即停止。　　---- starmap(func [, iterable]):生成值func(*item),其中item来自iterable，只有当iterable生成的项适用于这种调用函数的方式时，此函数才有效。　　　　　　starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000　　---- repeat(object [,times]):创建一个迭代器，重复生成object，times（如果已提供）指定重复计数，如果未提供times，将无止尽返回该对象。　　　　　　repeat(10, 3) --> 10 10 10　　---- product(iter1, iter2, ... iterN, [repeat=1]):生成item1，item2等中的项目的笛卡尔积的元组，repeat是一个关键字参数，指定重复生成序列的次数　　　　　　product(‘ABCD‘, ‘xy‘) --> Ax Ay Bx By Cx Cy Dx Dy　　　　　　product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111

　　----1):ifilter:同filter  #ifilterfalse: 仅生成iterable中为False的项　　----2):izip：同zip　　　　　#izip_longest(iter1,... iterN, [fillvalue=None])：迭代过程会持续到所有输入迭代变量iter1,iter2等都耗尽为止，如果没有使用fillvalue关键字参数指定不同的值，则使用None来填充已经使用的迭代变量的值。　　----3)imap:  只要提供的一个迭代器不再生成值，迭代就会停止(例：list(imap(pow, (2,3,10), (5,2))) -->32,9)  不同map　　----4)islice

注意：{ｋｅｙ:value for key,value in b.items()} 这种方式生成字典比dict((key, value) for key, value in b.items())慢

*** ： ｐｙｔｈｏｎ 聚集函数　　----　执行聚集函数(比如 sum() , min() , max())　一个非常优雅的方式去结合数据计算与转换就是使用一个生成器表达式参数。