本文主要讲解“如何高效编写Python循环”。感兴趣的朋友不妨看看。本文介绍的方法简单、快速、实用。让边肖带你学习如何高效地编写Python循环。
0 前言
说到处理循环，我们习惯于使用for、while等等，比如依次打印每个列表中的字符：
Lis=['I '，' love '，' python'] foriinlis:print (I)我爱python，当打印内容中的字节数较少时，将所有字节加载到内存中后再打印，没问题。但是，如果现在有成千上万的车辆行驶轨迹，要求你分析每个客户的出行规律和交通堵塞情况，如果这是在单台机器上处理的话。
你可能要先面对，也可能忽略。只有写完代码之后，才能暴露出一个问题：outofmemory，这是实际项目中经常遇到的问题。
这个问题提醒我们，在处理数据时，编写高效利用内存的程序是非常重要的。今天我们就来讨论一下如何高效利用内存，节省内存，把事情做好。
其实Python准备了一个模块来处理这个事情，就是itertools模块。这个模块中几个函数的功能其实很容易理解。
我不打算笼统地介绍它们能实现的功能，但我想分析一下这些功能背后的实现代码，它们如何高效地节省内存，Python内核的贡献者如何写出漂亮的代码，这很有意思，不是吗？
好，我们走吧。希望你旅途愉快！
1 拼接元素
itertools中的链式函数实现了元素拼接。原型如下，参数*表示可变数量的参数。
链条(可拆卸)
应用如下：
加入[33] :列表(链(['I '，' love']，['python']，['非常'，'非常'))出[33] : ['I '，' love '，' python '，'非常'。
那么，链如何高效地节省内存呢？链的大致实现代码如下：
def chain(* s)可重复： for it iteriable : forelementity : yield元素上面的代码很容易理解。chain本质上返回一个生成器，因此它实际上一次将一个元素读入内存，因此它可以最有效地节省内存。
2 逐个累积
返回列表的累计汇总值，原型：
累加(可迭代[，func，* initial=无])
应用如下：
in [36] :列表的近似实现(累加([1，2，3，4，5，6]，lambdax，y:x * y))，out [36] : [1，2，6，24，120，720]累加。
实际累积值(iterable，func=operator.add，* initial=None): it=ITER(iterable)total=initialificialisnone : nbsp
; try: total = next(it) except StopIteration: return yield total for element in it: total = func(total, element) yield total
以上代码，你还好吗？与chain简单的yield不同，此处稍微复杂一点，yield有点像return，所以 yield total那行直接就返回一个元素，也就是iterable的第一个元素，因为任何时候这个函数返回的第一个元素就是它的第一个。又因为yield返回的是一个generator对象，比如名字gen，所以next(gen)时，代码将会执行到 for element in it:这行，而此时的迭代器it 已经指到iterable的第二个元素，OK，相信你懂了！
3 漏斗筛选
它是compress 函数，功能类似于漏斗功能，所以我称它为漏斗筛选，原型：
compress(data, selectors)
In [38]: list(compress('abcdefg',[1,1,0,1])) Out[38]: ['a', 'b', 'd']
容易看出，compress返回的元素个数等于两个参数中较短的列表长度。
它的大概实现代码：
def compress(data, selectors): return (d for d, s in zip(data, selectors) if s)
这个函数非常好用
4 段位筛选
扫描列表，不满足条件处开始往后保留，原型如下：
dropwhile(predicate, iterable)
应用例子：
In [39]: list(dropwhile(lambda x: x<3,[1,0,2,4,1,1,3,5,-5])) Out[39]: [4, 1, 1, 3, 5, -5]
实现它的大概代码如下：
def dropwhile(predicate, iterable): iteriterable = iter(iterable) for x in iterable: if not predicate(x): yield x break for x in iterable: yield x
5 段位筛选2
扫描列表，只要满足条件就从可迭代对象中返回元素，直到不满足条件为止，原型如下：
takewhile(predicate, iterable)
应用例子：
In [43]: list(takewhile(lambda x: x<5, [1,4,6,4,1])) Out[43]: [1, 4]
实现它的大概代码如下：
def takewhile(predicate, iterable): for x in iterable: if predicate(x): yield x else: break #立即返回
6 次品筛选
扫描列表，只要不满足条件都保留，原型如下：
dropwhile(predicate, iterable)
应用例子：
In [40]: list(filterfalse(lambda x: x%2==0, [1,2,3,4,5,6])) Out[40]: [1, 3, 5]
实现它的大概代码如下：
def dropwhile(predicate, iterable): iteriterable = iter(iterable) for x in iterable: if not predicate(x): yield x break for x in iterable: yield x
7 切片筛选
Python中的普通切片操作，比如：
lis = [1,3,2,1] lis[:1]
它们的缺陷还是lis 必须全部载入内存，所以更节省内存的操作islice，原型如下：
islice(iterable, start, stop[, step])
应用例子：
In [41]: list(islice('abcdefg',1,4,2)) Out[41]: ['b', 'd']
实现它的大概代码如下：
def islice(iterable, *args): s = slice(*args) start, stop, sstep = s.start or 0, s.stop or sys.maxsize, s.step or 1 it = iter(range(start, stop, step)) try: nextnexti = next(it) except StopIteration: for i, element in zip(range(start), iterable): pass return try: for i, element in enumerate(iterable): if i == nexti: yield element nextnexti = next(it) except StopIteration: for i, element in zip(range(i + 1, stop), iterable): pass
巧妙利用生成器迭代结束时会抛出异常StopIteration，做一些边界处理的事情。
8 细胞分裂
tee函数类似于我们熟知的细胞分裂，它能复制原迭代器n个，原型如下：
tee(iterable, n=2)
应用如下，可以看出复制出的两个迭代器是独立的
a = tee([1,4,6,4,1],2) In [51]: next(a[0]) Out[51]: 1 In [52]: next(a[1]) Out[52]: 1
实现它的代码大概如下：
def tee(iterable, n=2): it = iter(iterable) deques = [collections.deque() for i in range(n)] def gen(mydeque): while True: if not mydeque: try: newval = next(it) except StopIteration: return for d in deques: d.append(newval) yield mydeque.popleft() return tuple(gen(d) for d in deques)
tee 实现内部使用一个队列类型deques，起初生成空队列，向复制出来的每个队列中添加元素newval, 同时yield 当前被调用的mydeque中的最左元素。
9 map变体
starmap可以看做是map的变体，它能更加节省内存，同时iterable的元素必须也为可迭代对象，原型如下：
starmap(function, iterable)
应用它：
In [63]: list(starmap(lambda x,y: str(x)+'-'+str(y), [('a',1),('b',2),('c',3)])) Out[63]: ['a-1', 'b-2', 'c-3']
starmap的实现细节如下：
def starmap(function, iterable): for args in iterable: yield function(*args)
10 复制元素
repeat实现复制元素n次，原型如下：
repeat(object[, times])
应用如下：
In [66]: list(repeat(6,3)) Out[66]: [6, 6, 6] In [67]: list(repeat([1,2,3],2)) Out[67]: [[1, 2, 3], [1, 2, 3]]
它的实现细节大概如下：
def repeat(object, times=None): if times is None:# 如果times不设置，将一直repeat下去 while True: yield object else: for i in range(times): yield object
11 笛卡尔积
笛卡尔积实现的效果同下：
((x,y) for x in A for y in B)
所以，笛卡尔积的实现效果如下：
In [68]: list(product('ABCD', 'xy')) Out[68]: [('A', 'x'), ('A', 'y'), ('B', 'x'), ('B', 'y'), ('C', 'x'), ('C', 'y'), ('D', 'x'), ('D', 'y')]
它的实现细节：
def product(*args, repeat=1): pools = [tuple(pool) for pool in args] * repeat result = [[]] for pool in pools: result = [x+[y] for x in result for y in pool] for prod in result: yield tuple(prod)
12 加强版zip
组合值。若可迭代对象的长度未对齐，将根据 fillvalue 填充缺失值，注意：迭代持续到耗光最长的可迭代对象，效果如下：
In [69]: list(zip_longest('ABCD', 'xy', fillvalue='-')) Out[69]: [('A', 'x'), ('B', 'y'), ('C', '-'), ('D', '-')]
它的实现细节：
def zip_longest(*args, fillvalue=None): iterators = [iter(it) for it in args] num_active = len(iterators) if not num_active: return while True: values = [] for i, it in enumerate(iterators): try: value = next(it) except StopIteration: num_active -= 1 if not num_active: return iterators[i] = repeat(fillvalue) value = fillvalue values.append(value) yield tuple(values)
它里面使用repeat，也就是在可迭代对象的长度未对齐时，根据 fillvalue 填充缺失值。理解上面代码的关键是迭代器对象(iter)，next方法的特殊性：I
n [74]: for i, it in enumerate([iter([1,2,3]),iter(['x','y'])]): ...: print(next(it)) #输出： 1 x
到此，相信大家对“怎么高效写Python循环”有了更深的了解，不妨来实际操作一番吧！这里是网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！
内容来源网络，如有侵权，联系删除，本文地址：https://www.230890.com/zhan/67434.html