可能重复:
如何在Python中将列表拆分为大小均匀的块？
我很惊讶我找不到一个"批处理"函数,它将输入迭代并返回一个可迭代的迭代.
例如:
for i in batch(range(0,10), 1): print i
[0]
[1]
...
[9]
要么:
for i in batch(range(0,10), 3): print i
[0,1,2]
[3,4,5]
[6,7,8]
[9]
现在,我写了一个我认为非常简单的生成器:
def batch(iterable, n = 1):
current_batch = []
for item in iterable:
current_batch.append(item)
if len(current_batch) == n:
yield current_batch
current_batch = []
if current_batch:
yield current_batch
但上面没有给我我所期望的:
for x in batch(range(0,10),3): print x
[0]
[0, 1]
[0, 1, 2]
[3]
[3, 4]
[3, 4, 5]
[6]
[6, 7]
[6, 7, 8]
[9] …我不知道是否有一个原因,有没有first(iterable)在Python内置的功能,有点类似于any(iterable)和all(iterable)(可能一STDLIB模块中夹着地方,但我没有看到它itertools).first将执行短路发生器评估,以便可以避免不必要的(和可能无限数量的)操作; 即
def identity(item):
return item
def first(iterable, predicate=identity):
for item in iterable:
if predicate(item):
return item
raise ValueError('No satisfactory value found')
这样你可以表达如下内容:
denominators = (2, 3, 4, 5)
lcd = first(i for i in itertools.count(1)
if all(i % denominators == 0 for denominator in denominators))
很明显,list(generator)[0]在这种情况下你不能这样做,因为发生器不会终止.
或者,如果你有一堆正则表达式匹配(当它们都具有相同的groupdict接口时很有用):
match = first(regex.match(big_text) for regex in regexes)
通过避免list(generator)[0]和短路匹配来节省大量不必要的处理.
我在Python 3.2中有一个代码,我想在Python 2.7中运行它.我确实转换了它(已经把missing_elements两个版本的代码都放了)但我不确定这是否是最有效的方法.基本上如果yield from在missing_element功能的上半部分和下半部分有两个如下所示的调用会发生什么？两个部分(上部和下部)中的条目是否在一个列表中相互附加,以便父级递归函数与yield from调用一起使用并将两个部分一起使用？
def missing_elements(L, start, end): # Python 3.2
if end - start <= 1:
if L[end] - L[start] > 1:
yield from range(L[start] + 1, L[end])
return
index = start + (end - start) // 2
# is the lower half consecutive?
consecutive_low = L[index] == L[start] + (index - start)
if not consecutive_low:
yield from missing_elements(L, start, index)
# is the upper part consecutive?
consecutive_high = L[index] …我想解析 2 个（可能）不同长度的生成器zip：
for el1, el2 in zip(gen1, gen2):
print(el1, el2)
但是，如果gen2元素较少，gen1则“消耗”一个额外的元素。
例如，
def my_gen(n:int):
for i in range(n):
yield i
gen1 = my_gen(10)
gen2 = my_gen(8)
list(zip(gen1, gen2)) # Last tuple is (7, 7)
print(next(gen1)) # printed value is "9" => 8 is missing
gen1 = my_gen(8)
gen2 = my_gen(10)
list(zip(gen1, gen2)) # Last tuple is (7, 7)
print(next(gen2)) # printed value is "8" => OK
显然，缺少一个值（8在我之前的示例中），因为在它意识到没有更多元素之前gen1被读取（从而生成值8） …
这不是作业,我只是好奇.
INFINITE是这里的关键词.
我希望在primes()中使用它作为p.我相信这是Haskell中的内置函数.
所以,答案不能像"Just do a Sieve"那样天真.
首先,您不知道将消耗多少连续素数.好吧,假设你可以一次编制100个.您是否会使用相同的Sieve方法以及素数公式的频率？
我更喜欢非并发方法.
感谢您阅读(和写作;))!
如果我想要迭代中的项目数量而不关心元素本身,那么获得该元素的pythonic方法是什么？现在,我会定义
def ilen(it):
return sum(itertools.imap(lambda _: 1, it)) # or just map in Python 3
但我明白lambda接近被认为是有害的,lambda _: 1当然不是很漂亮.
(这个用例是计算匹配正则表达式的文本文件中的行数,即grep -c.)
我正在研究与Koa一起构建一个Web应用程序,但是我还没有完全了解Hows,whens以及为什么选择 - 并应用 - 支持"使异步更容易"的技术/方法(下面列出).
总体而言,关于此主题的网络上的不同指南仍然使事情变得模糊,特别是在不断发展的最佳实践方面,或者至少是更好的方法,以及在什么情况下.在网络上似乎很少或根本没有把它全部放在上下文中.
我希望对这个大屁股庞大的帖子做出回应可以纠正这个问题.也许下面的问题可以激发某人写一篇完整的博客文章等来解决这个问题.我的感觉是,我甚至没有接近唯一一个从中受益的人.
因此,如果明亮的社区能够帮助回答并明确以下列出的技术(粗体字),我会很高兴:
- a)如何以及在何种情况下(如适用)它们相互补充,补充,替代和/或重叠解决方案？
- b)在速度性能,错误处理容易性和调试简易性方面,他们的权衡是什么？
- c)何时,何地以及为什么使用"this"与"that"技术,技术组合和/或方法更好？
- d)哪些技术或方法(如果有的话)可能是"调光星".
(希望可以很好地解释作为答案一部分的意见.)
==============================
技术:
*Koa*
我的理解:
Koa是构建节点应用程序的最小基础,旨在利用ECMAScript-6功能,其中一个特性是生成器.
*Co*
我的理解:
- Co是一个用于运行ECMAScript-6生成器(它们是Node .011和谐的本机)的实用程序库,目的是为了编写用于运行和管理生成器的样板代码的一些/多(？)需要.
- Co本质上是Koa(？)的一部分.
具体问题:
- 如果以及如何在Koa中使用Co而不是在非Koa上下文中使用Co.换句话说,Koa是完全立面Co吗？
- 如果有更好的产品库,Co可以用Koa替换其他类似的生成器库吗？有吗？
*承诺"Q"和Bluebird*等图书馆
我的理解:
- 它们在某种意义上是"polyfill"用于实现Promises/A +规范,如果Node直到运行该规范.
- 他们还有一些非规范的便利工具,用于促进使用承诺,例如Bluebird的promisfyAll实用程序.
具体问题:
- 我的理解是ECMAScript-6规范确实/将在很大程度上反映Promises/A +规范,但即便如此,Node 0.11v和谐本身并不实现Promises.(这是正确的吗？)但是当它出现时,Q和Bluebird等技术是否正在逐步推出？
- 我读过"Q"和Bluebird支持生成器的内容.这是什么意思？例如,它在某种程度上是否意味着它们在某种程度上提供了与Co相同的效用,如果是这样,那么在多大程度上呢？
*Thunk和Promises*
我认为我对它们是什么有一个公平的处理,但希望有人可以提供一个简洁明了的"电梯间距"定义每个是什么,当然,如上所述,解释何时使用一个与另一个 - 在Koa环境中而不是在它中.
具体问题:
- 使用像Thunkify(github com/visionmedia/node-thunkify)使用像Bluebird这样的东西的赞成和利弊？
==============================
为了给这篇文章及其问题提供一些进一步的背景,如果可以对以下网页中提供的Koa技术进行讨论和对比(特别是在优点与缺点的基础上),这可能会很有趣:
- a)www.marcusoft.net/2014/03/koaintro.html(在哪里是thunk或promises,还是我没有看到什么？)
- b)strongloop.com/strongblog/node-js-express-introduction-koa-js-zone(同样,那里是thunk还是promises？)
- c)github.com/koajs/koa/blob/master/docs/guide.md("下一个"参数等于什么,设置它和在哪里？)
- d)blog.peterdecroos.com/blog/2014/01/22/javascript-generators-first-impressions(不是在Koa上下文中,但是介绍了Co与promise库(Bluebird)的使用,所以我假设这里提供的技术/模式借出本身是用在Koa(？).如果是这样,那么有多好？
谢谢大家!
我天真地尝试创建一个递归生成器.没工作.这就是我做的:
def recursive_generator(lis):
yield lis[0]
recursive_generator(lis[1:])
for k in recursive_generator([6,3,9,1]):
print(k)
我得到的只是第一项6.
有没有办法使这样的代码工作？基本上yield在递归方案中将命令转移到上面的级别？
在这段代码中,为什么使用'for'会导致没有'StopIteration'或'for'循环捕获所有异常然后以静默方式退出？在这种情况下,为什么我们有无关的"回归"？或者是
for由:StopIteration？
#!/usr/bin/python3.1
def countdown(n):
print("counting down")
while n >= 9:
yield n
n -= 1
return
for x in countdown(10):
print(x)
c = countdown(10)
next(c)
next(c)
next(c)
假设for是由以下方式触发:return.GeneratorExit何时生成？
def countdown(n):
print("Counting down from %d" % n)
try:
while n > 0:
yield n
n = n - 1
except GeneratorExit:
print("Only made it to %d" % n)
如果我手动执行:
c = countdown(10)
c.close() #generates GeneratorExit??
在哪种情况下,为什么我看不到追溯？
可以说我有两个功能:
def foo():
return 'foo'
def bar():
yield 'bar'
第一个是正常函数,第二个是生成器函数.现在我想写这样的东西:
def run(func):
if is_generator_function(func):
gen = func()
gen.next()
#... run the generator ...
else:
func()
什么是直截了当的实现is_generator_function()？使用types包我可以测试是否 gen是生成器,但我希望在调用之前这样做func().
现在考虑以下情况:
def goo():
if False:
yield
else:
return
调用goo()将返回生成器.我假设python解析器知道该goo()函数有一个yield语句,我想知道是否可以轻松获取该信息.
谢谢!