匹配列表中的一个元素,然后返回它之前的“n”个元素和它之后的“m”个元素
Posted
技术标签:
【中文标题】匹配列表中的一个元素,然后返回它之前的“n”个元素和它之后的“m”个元素【英文标题】:Match an element in a list, then return `n` elements before it and `m` elements after it 【发布时间】:2012-05-03 09:17:26 【问题描述】:我的代码中的一个常见模式是:“搜索一个列表,直到找到一个特定元素,然后查看它之前和之后的元素。”
例如,我可能想查看一个日志文件,其中重要事件标有星号,然后提取重要事件的上下文。
在下面的例子中,我想知道为什么超光驱爆炸了:
Spinning up the hyperdrive
Hyperdrive speed 100 rpm
Hyperdrive speed 200 rpm
Hyperdrive lubricant levels low (100 gal.)
* CRITICAL EXISTENCE FAILURE
Hyperdrive exploded
我想要一个函数get_item_with_context()
,它允许我找到带星号的第一行,然后给我最多n
前面的行和m
后面的行。
我的尝试如下:
import collections, itertools
def get_item_with_context(predicate, iterable, items_before = 0, items_after = 0):
# Searches through the list of `items` until an item matching `predicate` is found.
# Then return that item.
# If no item matching predicate is found, return None.
# Optionally, also return up to `items_before` items preceding the target, and
# `items after` items after the target.
#
# Note:
d = collections.deque (maxlen = items_before + 1 + items_after)
iter1 = iterable.__iter__()
iter2 = itertools.takewhile(lambda x: not(predicate(x)), iter1)
d.extend(iter2)
# zero-length input, or no matching item
if len(d) == 0 or not(predicate(d[-1])):
return None
# get context after match:
try:
for i in xrange(items_after):
d.append(iter1.next())
except StopIteration:
pass
if ( items_before == 0 and items_after == 0):
return d[0]
else:
return list(d)
用法应该是这样的:
>>> get_item_with_context(lambda x: x == 3, [1,2,3,4,5,6],
items_before = 1, items_after = 1)
[2, 3, 4]
这个问题:
使用not(predicate(d[-1]))
检查以确保我们确实找到了匹配项,但由于某种原因无法正常工作。它总是返回 false。
如果找到匹配项后列表中的项少于items_after
,则结果为垃圾。
其他极端情况?
我能否就如何使这项工作/使其更强大提供一些建议?或者,如果我要重新发明***,也请随时告诉我。
【问题讨论】:
这是切片无法完成的事情吗? @BurhanKhalid:我可能正在使用无法重绕的可迭代对象。 你为什么用iterable.__iter__()
而不是iter(iterable)
?
@jamylak:因为我很傻。 ;)
我不明白你的结果。不应该是[2, 3, 4]
吗?另外我想知道是否可以通过 grep 等工具轻松完成某些事情,是否有选择 Python 的理由(除了你的讽刺回答,我很傻 :-))
【参考方案1】:
这似乎可以正确处理边缘情况:
from collections import deque
def item_with_context(predicate, seq, before=0, after=0):
q = deque(maxlen=before)
it = iter(seq)
for s in it:
if predicate(s):
return list(q) + [s] + [x for _,x in zip(range(after), it)]
q.append(s)
【讨论】:
我们赢了!简洁并通过了我所有的测试用例。谢谢你。 :) (使用zip()
的“以最短序列终止”行为来限制所采用的元素数量 - 这是一个很好的接触。)
有一个微妙的错误 - 从it
消耗了太多项目,因为zip(it, range(after))
在检查range(after)
中是否有任何内容之前需要it
的元素。如果您交换参数的顺序,它可以正常工作。我已经更正了您的代码。
@Li-aungYip:你能提供一个测试用例来显示这个错误吗?我不确定我是否理解。
当然。试试a = xrange(10); item_with_context(lambda x: x==3, a, 0, 0); a.next()
之类的东西。您希望函数将迭代器消耗到3
然后停止,因此a.next()
是4
。但是使用您的原始代码,您实际上会得到5
。【参考方案2】:
您可以使用collections.deque 对象获取上下文的环形缓冲区。要获得 +/- 2 行上下文,请像这样初始化它:
context = collections.deque(maxlen=5)
然后遍历你喜欢的任何内容,为每一行调用这个:
context.append(line)
在context[2]
上匹配,并为每个匹配输出整个双端队列内容。
【讨论】:
这实际上是我的示例代码尝试做的事情,假设您要查找的元素确实存在,并且在它之前和之后有适当数量的元素,它工作得很好。但是有很多边缘情况。【参考方案3】:这可能是一个完全“非pythonic”的解决方案:
import itertools
def get_item_with_context(predicate, iterable, items_before = 0, items_after = 0):
found_index = -1
found_element = None
before = [None] * items_before # Circular buffer
after = []
after_index = 0
for element, index in zip(iterable, itertools.count()):
if found_index >= 0:
after += [element]
if len(after) >= items_after:
break
elif predicate(element):
found_index = index
found_element = element
if not items_after:
break
else:
if items_before > 0:
before[after_index] = element
after_index = (after_index + 1) % items_before
if found_index >= 0:
if after_index:
# rotate the circular before-buffer into place
before = before[after_index:] + before[0:after_index]
if found_index - items_before < 0:
# slice off elements that "fell off" the start
before = before[items_before - found_index:]
return before, found_element, after
return None
for index in range(0, 8):
x = get_item_with_context(lambda x: x == index, [1,2,3,4,5,6], items_before = 1, items_after = 2)
print(index, x)
输出:
0 None
1 ([], 1, [2, 3])
2 ([1], 2, [3, 4])
3 ([2], 3, [4, 5])
4 ([3], 4, [5, 6])
5 ([4], 5, [6])
6 ([5], 6, [])
7 None
我冒昧地更改了输出,以使与谓词匹配的内容以及之前和之后的内容更加清晰:
([2], 3, [4, 5])
^ ^ ^
| | +-- after the element
| +------- the element that matched the predicate
+----------- before the element
函数句柄:
项目未找到,返回None
(如果您想返回其他内容,则返回函数的最后一行)
之前的元素未完全实现(即,找到的元素距离开始太近,无法真正获得之前的 N
元素)
后元素未完全实现(对于太接近结尾也是如此)
items_before 或 items_after 设置为 0(没有该方向的上下文)
它使用:
用于前元素的简单循环缓冲区,可旋转到位以按正确顺序获取元素 前元素的简单列表 任何可迭代的,不需要可索引的集合,不会多次枚举任何元素,并且会在找到所需的上下文后停止【讨论】:
您可以说服 python 双端队列充当循环缓冲区(通过使用 max_length 参数对其进行初始化)。这可能比滚动您自己的循环缓冲区更好。 ;)【参考方案4】:from itertools import takewhile, tee, chain
from collections import deque
def contextGet(iterable, predicate, before, after):
iter1, iter2 = tee(iterable)
beforeLog = deque(maxlen = before)
for item in takewhile(lambda x: not(predicate(x)), iter1):
beforeLog.append(item)
iter2.next()
afterLog = []
for i in xrange(after + 1):
try:
afterLog.append(iter2.next())
except StopIteration:
break
return chain(beforeLog, afterLog)
或者:
def contextGet(iterable, predicate, before, after):
it1, it2 = tee(it)
log = deque(maxlen = (before + after + 1))
for i in chain(dropwhile(lambda x: not predicate(x), it1), xrange(after + 1)):
try:
log.append(it2.next())
except StopIteration:
break
return log
如果列表的其余部分比after
参数短,则第二个可能会返回过多的“之前”元素。
【讨论】:
【参考方案5】:我不确定我是否遗漏了问题中的某些内容,但这可以简单地完成
>>> def get_item_with_context(predicate, iterable, items_before = 0, items_after = 0):
queue = collections.deque(maxlen=items_before+1)
found = False
for e in iterable:
queue.append(e)
if not found and predicate(e):
queue = collections.deque(queue,items_before+1+items_after)
found = True
if found:
if not items_after : break
items_after-=1
if not found:
queue.clear()
return list(queue)
>>> get_item_with_context(lambda x: x == 0, [1,2,3,4,5,6],items_before = 2, items_after = 1)
[]
>>> get_item_with_context(lambda x: x == 4, [1,2,3,4,5,6],items_before = 2, items_after = 1)
[2, 3, 4, 5]
>>> get_item_with_context(lambda x: x == 1, [1,2,3,4,5,6],items_before = 2, items_after = 1)
[1, 2]
>>> get_item_with_context(lambda x: x == 6, [1,2,3,4,5,6],items_before = 2, items_after = 1)
[4, 5, 6]
>>> get_item_with_context(lambda x: x == 4, [1,2,3,4,5,6],items_before = 20, items_after = 10)
[1, 2, 3, 4, 5, 6]
【讨论】:
【参考方案6】:import collections
def context_match(predicate, iterable, before = 0, after = 0):
pre = collections.deque(maxlen = before + 1)
post = []
match = 0
for el in iterable:
if not match:
pre.append(el)
if predicate(el):
match = 1
elif match:
if len(post) == after:
break
post.append(el)
if not match:
return
output = list(pre)
output.extend(post)
return output
for val in xrange(8):
print context_match(lambda x: x == val, [1,2,3,4,5,6],before = 2, after = 2)
#Output:
None
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[2, 3, 4, 5, 6]
[3, 4, 5, 6]
[4, 5, 6]
None
【讨论】:
【参考方案7】:这里有一些更短的内容:
import collections
from itertools import islice
def windowfilter(pred, it, before=0, after=0):
size = before + 1 + after
q = collections.deque(maxlen=size)
it = iter(it)
for x in it:
q.append(x)
if pred(x):
# ok we got the item, add the trailing lines
more = list(islice(it, after))
q.extend(more)
# maybe there were too few items left
got = before + 1 + len(more)
# slice from the end
return tuple(q)[-got:]
测试结果:
seq = [1,2,3,4,5,6]
for elem in range(8):
print elem, windowfilter((lambda x:x==elem), seq, 2, 1)
# Output:
0 None
1 (1, 2)
2 (1, 2, 3)
3 (1, 2, 3, 4)
4 (2, 3, 4, 5)
5 (3, 4, 5, 6)
6 (4, 5, 6)
7 None
【讨论】:
【参考方案8】:我的答案是这样的,
for k,v in enumerate(iterable):
#if cmp(v,predicate) == 0:
if v == predicate:
if k+items_after < len(iterable):
res.append((' '.join(token[(k-items_before):(k+items_after+1)])))
elif k+window == len(token):
res.append((' '.join(token[(k-items_before):])))
else:
res.append((' '.join(token[(k-items_before):])))
return res
【讨论】:
以上是关于匹配列表中的一个元素,然后返回它之前的“n”个元素和它之后的“m”个元素的主要内容,如果未能解决你的问题,请参考以下文章
python中编写一个模块,模块中包含随机生成N个元素的列表、排序列表、求最大