blocks|key|4044019|text|对于列表理解方法，您可以结合使用index和enumerate|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4044020|firstIndex+=+nums.index(0)+if+0+in+nums+else+-1
[1+if+i+<+firstIndex+else+0+for+i,+x+in+enumerate(nums)]|code-block|syntax|javascript|4044021|另一种使用numpy的方法|4044022|import+numpy+as+np
print(np.cumprod(np.array(nums)+!=+0).tolist())
#[1,+1,+0,+0,+0]|4044023|在这里，我们将nums转换为numpy数组，并检查这些值是否不等于0。然后我们得到数组的累积乘积，知道一旦找到0，我们就会从那个点开始乘以0。|4044024|entityMap^0|G|5|M|9|0|0|5|5|0|0|7|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

For a list comprehension approach, you could use <code>index</code> with <code>enumerate</code>:

<pre><code>firstIndex = nums.index(0) if 0 in nums else -1
[1 if i &lt; firstIndex else 0 for i, x in enumerate(nums)]
</code></pre>

Another approach using <code>numpy</code>:

<pre><code>import numpy as np
print(np.cumprod(np.array(nums) != 0).tolist())
#[1, 1, 0, 0, 0]
</code></pre>

Here we take the convert <code>nums</code> to a numpy array and check to see if the values are not equal to 0. We then take the cumulative product of the array, knowing that once a 0 is found we will multiply by 0 from that point forward.

blocks|key|4044058|text|在某些上下文中，列表理解是存在于许多函数式编程语言中的map和filter函数的一种“命令式”语法。您尝试执行的操作通常称为accumulate，这是一个稍有不同的操作。您不能用map和filter来实现accumulate，除非使用副作用。Python允许你在列表理解中有副作用，所以这绝对是可能的，但是有副作用的列表理解有点不可靠。下面是如何使用accumulate实现此功能：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4044059|nums+=+[1,1,0,1,1]

def+accumulator(last,+cur):
++++return+1+if+(last+==+1+and+cur+==+1)+else+0

list(accumulate(nums,+accumulator))|code-block|syntax|javascript|4044060|或者一行：|4044061|list(accumulate(nums,+lambda+last,+cur:+1+if+(last+==+1+and+cur+==+1)+else+0))|4044062|当然，有几种方法可以使用外部状态和带有副作用的列表理解来做到这一点。这里有一个例子，它有点冗长，但非常明确地说明了状态是如何被操纵的：|4044063|class+MyState:
++++def+__init__(self,+initial_state):
++++++++self.state+=+initial_state
++++def+getNext(self,+cur):
++++++++self.state+=+accumulator(self.state,+cur)
++++++++return+self.state

mystate+=+MyState(1)
[mystate.getNext(x)+for+x+in+nums]|4044064|entityMap^0|R|3|V|6|1Q|A|2H|3|2L|6|2U|A|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|T|$]]

Some context, a list comprehension is a sort of "imperative" syntax for the <code>map</code> and <code>filter</code> functions that exist in many functional programing languages. What you're trying to do is usually referred to as an <code>accumulate</code>, which is a slightly different operation. You can't implement an <code>accumulate</code> in terms of a <code>map</code> and <code>filter</code> except by using side effects. Python allows you have side effects in a list comprehension so it's definitely possible but list comprehensions with side effects are a little wonky. Here's how you could implement this using accumulate:

<pre><code>nums = [1,1,0,1,1]

def accumulator(last, cur):
 return 1 if (last == 1 and cur == 1) else 0

list(accumulate(nums, accumulator))
</code></pre>

or in one line:

<pre><code>list(accumulate(nums, lambda last, cur: 1 if (last == 1 and cur == 1) else 0))
</code></pre>

Of course there are several ways to do this using an external state and a list comprehension with side effects. Here's an example, it's a bit verbose but very explicit about how state is being manipulated:

<pre><code>class MyState:
 def __init__(self, initial_state):
 self.state = initial_state
 def getNext(self, cur):
 self.state = accumulator(self.state, cur)
 return self.state

mystate = MyState(1)
[mystate.getNext(x) for x in nums]
</code></pre>

blocks|key|4043332|text|我有一个使用列表理解的答案，但@Prune抢先了我一步。这真的只是一条警示的尾巴，显示了如何在反对该方法的同时完成它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4043333|以下是一种可能适合您需求的替代方法：|4043334|import+itertools
import+operator

nums+=+[1,1,0,1,1]
res+=+itertools.accumulate(nums,+operator.and_)|code-block|syntax|javascript|4043335|在本例中，res是一个可迭代的。如果你需要一个列表，那么|offset|length|style|CODE|4043336|res+=+list(itertools.accumulate(nums,+operator.and_))|4043337|让我们来分析一下。accumulate()函数可用于生成运行总数或“累积和”。如果只传递了一个参数，则默认函数为addition。这里我们传入operator.and_。operator模块导出一组与Python的内部运算符相对应的高效函数。当在0和1的列表上运行累加的and时，结果是一个列表，在找到第一个0之前是1，然后是所有0。|4043338|当然，我们并不局限于使用operator模块中定义的函数。您可以使用任何接受第一个参数中元素类型的2个参数的函数(并且可能返回相同的类型)。您可以发挥创造力，但在这里我将保持简单，只实现and|4043339|import+itertools

nums+=+[1,1,0,1,1]
res+=+itertools.accumulate(nums,+lambda+a,+b:+a+and+b)|4043340|注意:使用operator.and_可能运行得更快。在这里，我们只是提供一个使用lambda语法的示例。|4043341|虽然没有使用列表理解，但对我来说有类似的感觉。它只有一行，读起来不是很难。|4043342|entityMap^0|0|0|0|5|3|0|0|9|C|2D|8|3R|3|0|C|8|2L|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@$K|16|L|17|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|19|8|@$K|1A|L|1B|M|N]|$K|1C|L|1D|M|N]|$K|1E|L|1F|M|N]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@$K|1H|L|1I|M|N]|$K|1J|L|1K|M|N]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1L|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1N|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|11|$]]

I had an answer using list comprehension, but @Prune beat me to it. It was really just a cautionary tail, showing how it would be done while making an argument against that approach.

Here's an alternative approach that might fit your needs:

<pre><code>import itertools
import operator

nums = [1,1,0,1,1]
res = itertools.accumulate(nums, operator.and_)
</code></pre>

In this case <code>res</code> is an iterable. If you need a list, then

<pre><code>res = list(itertools.accumulate(nums, operator.and_))
</code></pre>

Let's break this down. The <code>accumulate()</code> function can be used to generate a running total, or 'accumulated sums'. If only one argument is passed the default function is addition. Here we pass in operator.and_. The <code>operator</code> module exports a set of efficient functions corresponding to the intrinsic operators of Python. When an accumulated <code>and</code> is run on a list of 0's and 1's the result is a list that has 1's up till the first 0 is found, then all 0's after.

Of course we're not limited to using functions defined in the <code>operator</code> module. You can use any function that accepts 2 parameters of the type of the elements in the first parameter (and probably returns the same type). You can get creative, but here I'll keep it simple and just implement <code>and</code>:

<pre><code>import itertools

nums = [1,1,0,1,1]
res = itertools.accumulate(nums, lambda a, b: a and b)
</code></pre>

Note: using operator.and_ probably runs faster. Here we're just providing an example using the lambda syntax.

While a list comprehension is not used, to me it has a similar feel. It fits in one line and isn't too hard to read.

blocks|key|4044187|text|这是一个线性时间解决方案，它不会改变全局状态，不需要除nums之外的任何其他迭代器，它做了您想要的事情，尽管需要一些辅助数据结构，并使用了非常繁琐的列表理解：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4044188|>>>+nums+=+[1,1,0,1,1]
>>>+[f+for+f,+ns+in+[(1,+nums)]+for+n+in+ns+for+f+in+[f+&+(n==1)]]
[1,+1,+0,+0,+0]|code-block|syntax|javascript|4044189|不要用这个。使用原始的for-loop。它的可读性更好，而且几乎可以肯定更快。不要试图把所有的东西都放在一个列表中--理解。努力使您的代码简单、可读和可维护，这是您的代码已经做到的，而上面的代码却不是。|4044190|entityMap^0|R|4|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Here is a linear-time solution that doesn't mutate global state, doesn't require any other iterators except the <code>nums</code>, and that does what you want, albeit requiring some auxiliary data-structures, and using a seriously hacky list-comprehension:

<pre><code>&gt;&gt;&gt; nums = [1,1,0,1,1]
&gt;&gt;&gt; [f for f, ns in [(1, nums)] for n in ns for f in [f &amp; (n==1)]]
[1, 1, 0, 0, 0]
</code></pre>

Don't use this. Use your original for-loop. It is more readable, and almost certainly faster. Don't strive to put everything in a list-comprehension. Strive to make your code simple, readable, and maintainable, which your code already was, and the above code is not.

How can I do the following in Python's list comprehension?

<pre><code>nums = [1,1,0,1,1]
oFlag = 1
res = []
for x in nums:
 if x == 0:
 oFlag = 0
 res.append(oFlag)
print(res)

# Output: [1,1,0,0,0]
</code></pre>

Essentially in this example, zero out the rest of the list once a <code>0</code> occurs.

Python's list comprehension: Modify list elements if a certain value occurs

数据结构

Python

如何在Python的列表理解中执行以下操作？nums = [1,1,0,1,1]oFlag = 1res = []for x in nums:    if x == 0:        oFlag = 0    res.append(oFlag)print(res)# Output: [1,1,0,0,0]实际上，在本...

问Python的列表理解:如果出现某个值，则修改列表元素
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python的列表理解:如果出现某个值，则修改列表元素EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python的列表理解:如果出现某个值，则修改列表元素
EN