blocks|key|818150|text|按降序排序索引列表。如果首先删除最大索引，则不可能影响序列前面元素的索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|818151|deleted_records+=+[]
tokens+=+['hi',+'what',+'is',+'there']
indices_to_remove+=+[2,3]
for+index+in+sorted(indices_to_remove,+reverse=True):+
++++deleted_tokens.append(tokens[index])
++++del+tokens[index]|code-block|syntax|javascript|818152|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Sort the indices list in descending order. If you remove the biggest index first, it can't possibly affect the index of elements earlier in the sequence.
<pre><code>deleted_records = []
tokens = ['hi', 'what', 'is', 'there']
indices_to_remove = [2,3]
for index in sorted(indices_to_remove, reverse=True): 
 deleted_tokens.append(tokens[index])
 del tokens[index]
</code></pre>

blocks|key|2457116|text|在迭代集合的同时修改集合通常不是一个好主意。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2457117|因此，最简单的方法是维护两个列表来收集这样的结果|2457118|removed,+retained+=+[],+[]
tokens+=+['hi',+'what',+'is',+'there']
indices_to_remove+=+{2,+3}+#+Set+for+faster+lookups

for+idx,+token+in+enumerate(tokens):
+++++selected_list+=+removed+if+idx+in+indices_to_remove+else+retained
+++++selected_list.append(token)

print(removed,+retained)|code-block|syntax|javascript|2457119|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Its generally not a good idea to modify a collection while iterating it.
So, the simplest way is to maintain two lists to gather the results like this
<pre><code>removed, retained = [], []
tokens = ['hi', 'what', 'is', 'there']
indices_to_remove = {2, 3} # Set for faster lookups

for idx, token in enumerate(tokens):
 selected_list = removed if idx in indices_to_remove else retained
 selected_list.append(token)

print(removed, retained)
</code></pre>

blocks|key|2462331|text|清单理解的速度很快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2462332|deleted+=+[tokens[i]+for+i+in+sorted(indices_to_remove)]
tokens+=+[e+for+i,+e+in+enumerate(tokens)+if+i+not+in+indices_to_remove]|code-block|syntax|javascript|2462333|但首先，考虑到问题中的一些含糊不清之处，为了表现起见，有些假设是：|2462334|2462335|indices_to_remove是一个set+(O(1)成员资格测试)，OP希望deleted保持与初始tokens+|ordered-list-item|offset|length|style|CODE|2462336|相同的顺序，所有的索引都是有效的(0+<=+i+<+len(tokens)对于所有i)。如果没有，那么你会得到一个IndexError.|2462337|2462338|速度试验|2462339|import+random
from+math+import+isqrt

def+gen(n):
++++tokens+=+[f'x-{i}'+for+i+in+range(n)]
++++indices_to_remove+=+set(random.sample(range(n),+isqrt(n)))
++++return+tokens,+indices_to_remove


#+our+initial+solution
def+f0(tokens,+indices_to_remove):
++++deleted+=+[e+for+i,+e+in+enumerate(tokens)+if+i+in+indices_to_remove]
++++tokens+=+[e+for+i,+e+in+enumerate(tokens)+if+i+not+in+indices_to_remove]
++++return+deleted,+tokens


#+improved+version,+based+on+a+comment+by+@KellyBundy
def+f1(tokens,+indices_to_remove):
++++deleted+=+[tokens[i]+for+i+in+sorted(indices_to_remove)]
++++tokens+=+[e+for+i,+e+in+enumerate(tokens)+if+i+not+in+indices_to_remove]
++++return+deleted,+tokens


#+@thefourtheye+version
def+f4(tokens,+indices_to_remove):
++++removed,+retained+=+[],+[]
++++for+idx,+token+in+enumerate(tokens):
++++++++selected_list+=+removed+if+idx+in+indices_to_remove+else+retained
++++++++selected_list.append(token)
++++return+removed,+retained


#+modified+Kelly_1+to+comply+with+our+assumptions
#+the+original+is+certainly+even+faster,+but+modifies
#+tokens+in+place,+so+harder+to+benchmark
def+Kelly_1(tokens,+indices_to_remove):
++++tokens+=+tokens.copy()
++++indices_to_remove+=+sorted(indices_to_remove)
++++return+[*map(tokens.pop,+reversed(indices_to_remove))][::-1],+tokens|2462340|测试：|2462341|tokens,+indices_to_remove+=+gen(1_000_000)

%25timeit+f0(tokens,+indices_to_remove)
134+ms+±+603+µs+per+loop+(mean+±+std.+dev.+of+7+runs,+10+loops+each)

%25timeit+f4(tokens,+indices_to_remove)
111+ms+±+34.8+µs+per+loop+(mean+±+std.+dev.+of+7+runs,+10+loops+each)

%25timeit+f1(tokens,+indices_to_remove)
76.9+ms+±+194+µs+per+loop+(mean+±+std.+dev.+of+7+runs,+10+loops+each)|2462342|下面是一个基准，用于查看运行时与规模的差异(令牌的长度；注意，要删除的令牌的数量总是~sqrt(n)+)。|2462343|import+perfplot

perfplot.show(
++++setup=gen,
++++kernels=[f0,+f1,+f4,+Kelly_1],
++++n_range=[2**k+for+k+in+range(3,+20)],
++++relative_to=1,
++++xlabel='n+elements',
++++equality_check=lambda+x,+y:+x+==+y,
)|2462344|📷|atomic|2462345|我们看到了关于Kelly_1的一些非常有趣的东西:尽管它做了一些额外的步骤(复制初始列表，以保护参数，对集合排序以使其成为排序列表)，但这绝对会抹掉所有其他解决方案，最多可达100+K元素。在那之后，时间大幅上升。我得弄明白为什么。|2462346|用Python3.9.0进行测试。|2462347|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/118eb995b37c9957182f840dd98db55e.png|imageAlt^0|0|0|0|0|0|H|K|3|15|7|1H|6|0|H|K|15|1|1L|A|0|0|0|0|0|0|16|8|0|0|0|1|0|0|7|7|0|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1N|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1P|8|@$M|1Q|N|1R|O|P]|$M|1S|N|1T|O|P]|$M|1U|N|1V|O|P]|$M|1W|N|1X|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1Y|8|@$M|1Z|N|20|O|P]|$M|21|N|22|O|P]|$M|23|N|24|O|P]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|25|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|26|8|@]|9|@]|A|$]]|$1|V|3|W|5|D|7|27|8|@]|9|@]|A|$E|F]]|$1|X|3|Y|5|6|7|28|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|29|8|@]|9|@]|A|$E|F]]|$1|11|3|12|5|6|7|2A|8|@$M|2B|N|2C|O|P]]|9|@]|A|$]]|$1|13|3|14|5|D|7|2D|8|@]|9|@]|A|$E|F]]|$1|15|3|16|5|17|7|2E|8|@]|9|@$M|2F|N|2G|1|2H]]|A|$]]|$1|18|3|19|5|6|7|2I|8|@$M|2J|N|2K|O|P]]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]]|1D|$1E|$5|1F|1G|1H|A|$1I|1J|1K|-4]]]]

List comprehensions are fast.
<pre class="lang-py prettyprint-override"><code>deleted = [tokens[i] for i in sorted(indices_to_remove)]
tokens = [e for i, e in enumerate(tokens) if i not in indices_to_remove]
</code></pre>
But first, given some ambiguity in the question, and for the sake of performance, some assumptions:
<ol>
<li><code>indices_to_remove</code> is a <code>set</code> (O(1) membership test).</li>
<li>The OP wants <code>deleted</code> to be in the same order as in the initial <code>tokens</code> list.</li>
<li>(Obviously) all indices are valid (<code>0 &lt;= i &lt; len(tokens)</code> for all <code>i</code>). If not, well, you'll get an <code>IndexError</code>.</li>
</ol>
<h3>Speed test</h3>
<pre class="lang-py prettyprint-override"><code>import random
from math import isqrt

def gen(n):
 tokens = [f'x-{i}' for i in range(n)]
 indices_to_remove = set(random.sample(range(n), isqrt(n)))
 return tokens, indices_to_remove


# our initial solution
def f0(tokens, indices_to_remove):
 deleted = [e for i, e in enumerate(tokens) if i in indices_to_remove]
 tokens = [e for i, e in enumerate(tokens) if i not in indices_to_remove]
 return deleted, tokens


# improved version, based on a comment by @KellyBundy
def f1(tokens, indices_to_remove):
 deleted = [tokens[i] for i in sorted(indices_to_remove)]
 tokens = [e for i, e in enumerate(tokens) if i not in indices_to_remove]
 return deleted, tokens


# @thefourtheye version
def f4(tokens, indices_to_remove):
 removed, retained = [], []
 for idx, token in enumerate(tokens):
 selected_list = removed if idx in indices_to_remove else retained
 selected_list.append(token)
 return removed, retained


# modified Kelly_1 to comply with our assumptions
# the original is certainly even faster, but modifies
# tokens in place, so harder to benchmark
def Kelly_1(tokens, indices_to_remove):
 tokens = tokens.copy()
 indices_to_remove = sorted(indices_to_remove)
 return [*map(tokens.pop, reversed(indices_to_remove))][::-1], tokens
</code></pre>
Test:
<pre class="lang-py prettyprint-override"><code>tokens, indices_to_remove = gen(1_000_000)

%timeit f0(tokens, indices_to_remove)
134 ms ± 603 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit f4(tokens, indices_to_remove)
111 ms ± 34.8 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit f1(tokens, indices_to_remove)
76.9 ms ± 194 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
</code></pre>
Here is a benchmark to see the runtime differences over scale (length of tokens; note, the number of tokens to delete is always <code>~sqrt(n)</code>:
<pre class="lang-py prettyprint-override"><code>import perfplot

perfplot.show(
 setup=gen,
 kernels=[f0, f1, f4, Kelly_1],
 n_range=[2**k for k in range(3, 20)],
 relative_to=1,
 xlabel='n elements',
 equality_check=lambda x, y: x == y,
)
</code></pre>
<img src="https://i.stack.imgur.com/vxMlG.png" width="400">
We see something very interesting about <code>Kelly_1</code>: even though it does some extra steps (copy the initial list, to protect the argument, sort the set to make it a sorted list), this absolutely obliterates all other solutions, up to about 100K elements. After that, the time ramps up significantly. I need to understand why.
Tested with Python 3.9.0.

blocks|key|818206|text|deleted_records+=+[]
tokens+=+['hi',+'what',+'is',+'there']
del_tokens+=+tokens%2B[]
indices_to_remove+=+[2,3]
for+index+in+indices_to_remove:+
++++deleted_records.append(tokens[index])
++++del_tokens[index]=''
del_tokens_real+=+[]
for+t+in+del_tokens:
++++if+t!='':
+++++++del_tokens_real.append(t)
print(del_tokens_real)
print(deleted_records)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|818207|首先，替换记录应该用'‘删除，然后从其中筛选其他记录以获得输出。否则，由于列表大小在删除期间发生更改，可能会出现问题。|unstyled|818208|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>deleted_records = []
tokens = ['hi', 'what', 'is', 'there']
del_tokens = tokens+[]
indices_to_remove = [2,3]
for index in indices_to_remove: 
 deleted_records.append(tokens[index])
 del_tokens[index]=''
del_tokens_real = []
for t in del_tokens:
 if t!='':
 del_tokens_real.append(t)
print(del_tokens_real)
print(deleted_records)
</code></pre>
First replace records should delete with '' and then filter other records from it to get the output. Otherwise as the list size change during the delete issues can occur.

blocks|key|821167|text|两个解决方案..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|821168|这个值从后面弹出(依赖于排序的indices_to_remove+)：|offset|length|style|CODE|821169|def+Kelly_1(tokens,+indices_to_remove):
++++return+[*map(tokens.pop,+reversed(indices_to_remove))][::-1],+tokens|code-block|syntax|javascript|821170|此方法获取所请求的值，然后使用片将其他值复制到单独的列表中。支持未排序的indices_to_remove。如果对其进行排序，则可以删除sorted调用。|821171|def+Kelly_2(tokens,+indices_to_remove):
++++removed+=+[tokens[i]+for+i+in+indices_to_remove]
++++retained+=+[]
++++start+=+0
++++for+i+in+sorted(indices_to_remove):
++++++++retained+%2B=+tokens[start:i]
++++++++start+=+i+%2B+1
++++retained+%2B=+tokens[start:]
++++return+removed,+retained|821172|entityMap^0|0|F|H|0|0|10|H|1W|6|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

Two solutions...
This one pops the values from back to front (relies on <code>indices_to_remove</code> being sorted):
<pre><code>def Kelly_1(tokens, indices_to_remove):
 return [*map(tokens.pop, reversed(indices_to_remove))][::-1], tokens
</code></pre>
This one gets the requested values and then copies the other values into a separate list using slices. Supports <code>indices_to_remove</code> being unsorted. If it's sorted, the <code>sorted</code> call can be removed.
<pre><code>def Kelly_2(tokens, indices_to_remove):
 removed = [tokens[i] for i in indices_to_remove]
 retained = []
 start = 0
 for i in sorted(indices_to_remove):
 retained += tokens[start:i]
 start = i + 1
 retained += tokens[start:]
 return removed, retained
</code></pre>

I want to remove elements from an original list tokens which are at specified indices indices_to_remove and also keep the record of the deleted records but the problem is that when I have two indices to remove and I remove the record from first index, the second record cannot be removed correctly. Any idea on how to address this?
<pre><code>deleted_records = []
tokens = ['hi', 'what', 'is', 'there']
indices_to_remove = [2,3]
for index in indices_to_remove: 
 deleted_tokens.append(tokens[index])
 del tokens[index]
</code></pre>

removing multiple elements from a list and keeping track of them

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我希望从位于指定索引indices_to_remove的原始列表标记中删除元素，并保留已删除记录的记录，但问题是，当我有两个索引要删除并从第一个索引中删除记录时，第二个记录无法正确删除。知道怎么解决这个问题吗？deleted_records = []tokens = ['hi', 'what', 'is', 'ther...

问从列表中删除多个元素并跟踪它们
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从列表中删除多个元素并跟踪它们EN