blocks|key|2127774|text|我不知道4-5是什么意思？是字符串还是操作？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2127775|不管怎样，假设这是你想要的，你可以这样做：|2127776|A+=+[4-5,3-6,3-3,+9-0]
B+=+[4-4,+4-5,+3-3,+6-9,+5-5,+3-2,+6-6,+9-9,+9,0]

a+=+set(A)
b+=+set(B)

print+b+-+a|code-block|syntax|javascript|2127777|entityMap^0|4|3|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|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

I don't know what <code>4-5</code> means? is it a string, an operation?

Anyways, assuming it is whatever you meant it to be you can do as follows:

<pre><code>A = [4-5,3-6,3-3, 9-0]
B = [4-4, 4-5, 3-3, 6-9, 5-5, 3-2, 6-6, 9-9, 9,0]

a = set(A)
b = set(B)

print b - a
</code></pre>

blocks|key|2536925|text|别费心分类了。使用sets代替，并计算差额：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2536926|A+=+['4-5','3-6','3-3',+'9-0']
B+=+['4-4',+'4-5',+'3-3',+'6-9',+'5-5',+'3-2',+'6-6',+'9-9',+'9','0']

print(set(B)+-+set(A))
>>+{'0',+'6-9',+'9-9',+'5-5',+'3-2',+'6-6',+'4-4',+'9'}|code-block|syntax|javascript|2536927|您所需的输出是[4-4,+6-9,+5-5,+3-2,+6-6,+9-9]。您要么遗漏了一些，要么打算将'9'视为'9-0'。|offset|length|style|CODE|2536928|entityMap^0|0|0|7|U|1G|3|1L|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

Don't bother sorting. Use sets instead and calculate the difference:

<pre><code>A = ['4-5','3-6','3-3', '9-0']
B = ['4-4', '4-5', '3-3', '6-9', '5-5', '3-2', '6-6', '9-9', '9','0']

print(set(B) - set(A))
&gt;&gt; {'0', '6-9', '9-9', '5-5', '3-2', '6-6', '4-4', '9'}
</code></pre>

Your required out put was <code>[4-4, 6-9, 5-5, 3-2, 6-6, 9-9]</code>. You either missed a few, or you meant to treat <code>'9'</code> as <code>'9-0'</code>.

blocks|key|2536936|text|你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2536937|>>>+A+=+['4-5','3-6','3-3','9-0']+
>>>+B=['4-4','4-5','3-3','6-9','5-5','3-2','6-6','9-9','9','0']
>>>+set(B)-set(A)
set(['5-5',+'4-4',+'9-9',+'3-2',+'0',+'6-9',+'9',+'6-6'])
>>>+|code-block|syntax|javascript|2536938|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|$]]

You could do this:

<pre><code>&gt;&gt;&gt; A = ['4-5','3-6','3-3','9-0'] 
&gt;&gt;&gt; B=['4-4','4-5','3-3','6-9','5-5','3-2','6-6','9-9','9','0']
&gt;&gt;&gt; set(B)-set(A)
set(['5-5', '4-4', '9-9', '3-2', '0', '6-9', '9', '6-6'])
&gt;&gt;&gt; 
</code></pre>

blocks|key|1329213|text|简单的清单理解也。不知道为什么要对输入进行排序，我不认为这真的是必要的，但我已经对输出进行了排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1329214|A+=+["4-5",'3-6','3-3',+'9-0']
B+=+['4-4',+'4-5',+'3-3',+'6-9',+'5-5',+'3-2',+'6-6',+'9-9',+'9','0']+
new+=+sorted([x+for+x+in+B+if+x+not+in+A])|code-block|syntax|javascript|1329215|尽管您的预期输出不包括最后两个条目"9“和"0"，或者"9,0”，但这取决于解释|1329216|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Simple in a list comprehension too. Not sure why you would sort the inputs, I don't see that it's really necessary, but I've sorted the output.

<pre><code>A = ["4-5",'3-6','3-3', '9-0']
B = ['4-4', '4-5', '3-3', '6-9', '5-5', '3-2', '6-6', '9-9', '9','0'] 
new = sorted([x for x in B if x not in A])
</code></pre>

though your expected output doesn't include the last two entries "9" and "0", or "9,0" depending on interpretation

blocks|key|2537009|text|在大多数情况下，最好的方法是忽略数据被排序的事实，只执行set(B)+-+set(A)。如果您确实需要一个结果列表，也可以使用list(set(B)+-+set(A))。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2537010|但是，这有相当大的空间开销(大约是两个输入列表的大小之和)。通常这没什么好担心的，但是如果数据非常大(占用一半以上的可用内存)，那么您可能会发现需要减少这一点。你可以先试试：|2537011|A_set+=+set(A)
result+=+[b+for+b+in+B+if+b+not+in+A_set]|code-block|syntax|javascript|2537012|这避免了为B构造集合或为差异构造集合，因此开销大约为A的大小。|2537013|出于您的兴趣，或者对于资源受到非常严格限制的情况，您可能希望知道，如果A和B已经排序(在您的示例中它们没有排序，但您保证它们会排序)，那么只需要恒定的空间开销就可以做到这一点。诀窍是，当您查找A中的每个B元素时，请注意：|2537014|你可以按顺序搜索A，当你找到一个不小于你要找的元素时，你就停止搜索。在那之后你就找不到了，因为A是排序的。|unordered-list-item|2537015|如果您找到了B的前一个元素，那么您将不会在A中找到B的前一个元素之前找到下一个元素，因为这两个列表都是排序的。|2537016|如果您没有找到B的前一个元素，那么您也不会在停止查找的地方之前找到它。|2537017|因此，在每一步中，我们都可以从上次停止的地方恢复搜索。|2537018|综合起来，这意味着我们可以对每个输入A和B同时进行一次传递，在这个过程中决定B的每个元素是否在A中。如果您熟悉合并排序(或合并)，那么请注意，流程类似于合并，但是输出是不同的。不仅开销为零，而且对于高级用途，我们甚至不需要列表，我们可以在生成器中完成这一切，这样输入就不一定都同时存在于内存中。但要坚持用清单来说明这一点：|2537019|def+find_element(elt,+arr,+idx):
++++while+idx+<+len(arr)+and+elt+>+arr[idx]:
++++++++#+haven't+found+it+yet
++++++++idx+%2B=+1
++++#+have+found+the+place+where+it+would+go,+but+is+it+here?
++++if+idx+<+len(arr)+and+elt+==+arr[idx]:
++++++++#+it's+here
++++++++return+True,+idx+%2B+1
++++#+not+found
++++return+False,+idx

a_idx+=+0
b_idx+=+0
results+=+[]
while+a_idx+<+len(A)+and+b_idx+<+len(B):
++++found,+a_idx+=+find_element(B[b_idx],+A,+a_idx)
++++if+not+found:
++++++++results.append(B[b_idx])
++++b_idx+%2B=+1
#+if+there's+anything+left+in+B+to+check+then+it's+definitely+not+in+A
results.extend(itertools.islice(B,+b_idx,+None))|2537020|最后，我们可以使用二进制搜索而不是线性搜索来提高大型数组的find_element速度。我将此留作读者练习：)|2537021|entityMap^0|S|F|1R|L|0|0|0|0|Z|1|11|1|0|0|0|0|0|I|1|K|1|12|1|1B|1|0|0|T|C|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1C|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1E|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|S|7|1K|8|@]|D|@]|E|$]]|$1|T|3|U|5|S|7|1L|8|@]|D|@]|E|$]]|$1|V|3|W|5|S|7|1M|8|@]|D|@]|E|$]]|$1|X|3|Y|5|S|7|1N|8|@]|D|@]|E|$]]|$1|Z|3|10|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|11|3|12|5|J|7|1X|8|@]|D|@]|E|$K|L]]|$1|13|3|14|5|6|7|1Y|8|@$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|15|3|-4|5|6|7|21|8|@]|D|@]|E|$]]]|16|$]]

In most situations, the best way is to ignore the fact the data is sorted and just do <code>set(B) - set(A)</code>. Or <code>list(set(B) - set(A))</code> if you definitely need a list for the result.

However, that has a moderately large space overhead (approximately the sum of the sizes of the two input lists). Normally this is nothing to worry about, but if the data is very large (uses more than half your available memory) then you might find you need to reduce this. You could first try:

<pre><code>A_set = set(A)
result = [b for b in B if b not in A_set]
</code></pre>

This avoids constructing a set for B or a set for the difference, so the overhead is approximately the size of A.

For your interest, or for situations where resources are very tightly constrained, you might like to know that it's possible to do this with only constant-space overhead supposing that <code>A</code> and <code>B</code> are already sorted (which in your example they are not, but you promise they will be). The trick is to notice that as you look for each element of B in A:

<ul>
<li>you can search through A in order, and stop searching when you find an element no smaller than the one you're looking for. You won't find it after that because A is sorted.</li>
<li>if you found the previous element of B, then you will not find the next one before the place where you found the previous element of B in A, because both lists are sorted.</li>
<li>if you did not find the previous element of B, then you likewise will not find it before the place where you stopped looking.</li>
<li>therefore at each step we can resume searching from where we left off last time.</li>
</ul>

Putting it all together, this means we can make a single simultaneous pass over each of the inputs <code>A</code> and <code>B</code>, and in the process of this single pass decide for each element of <code>B</code> whether or not it is in <code>A</code>. If you're familiar with merge sort (or merging), then be aware that the process is similar to a merge, but the output is different. Not only is the overhead zero, but for advanced uses we don't even need lists, we can do it all in generators so that the input needn't necessarily even all be in memory at once. But sticking with lists to illustrate it:

<pre><code>def find_element(elt, arr, idx):
 while idx &lt; len(arr) and elt &gt; arr[idx]:
 # haven't found it yet
 idx += 1
 # have found the place where it would go, but is it here?
 if idx &lt; len(arr) and elt == arr[idx]:
 # it's here
 return True, idx + 1
 # not found
 return False, idx

a_idx = 0
b_idx = 0
results = []
while a_idx &lt; len(A) and b_idx &lt; len(B):
 found, a_idx = find_element(B[b_idx], A, a_idx)
 if not found:
 results.append(B[b_idx])
 b_idx += 1
# if there's anything left in B to check then it's definitely not in A
results.extend(itertools.islice(B, b_idx, None))
</code></pre>

Finally, we could potentially improve the speed of <code>find_element</code>, for large arrays, using a binary search instead of a linear search. I leave this as an exercise for the reader :-)

I am looking to see what is missing from a list (A) from list (B)

If I have the following list of strings:

<code>A = ['4-5', '3-6', '3-3', '9-0']</code> and <code>B = ['4-4', '4-5', '3-3', '6-9', '5-5', '3-2', '6-6', '9-9', '9,0']</code> and want to check what is missing from A that is in list B. 

A = [4-5,3-6,3-3, 9-0] 
B = [4-4, 4-5, 3-3, 6-9, 5-5, 3-6, 3-2, 6-6, 9-9, 9,0]

so... from the example from above, I would want it to output <code>['4-4', '6-9', '5-5', '3-2', '6-6', '9-9']</code>.

if I sort both the lists, what's the best way of going about it?

Thanks!

I t hought about doing something like:

<pre><code>unique = []
for n in A:
 if n not in B:
 unique.append(B)
print(unique)
</code></pre>

does this work? it's giving me a very odd output of a list in a list of two strings.

Checking WHAT is missing from a list when comparing it to another list python

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想看看清单(B)中缺少什么(A)如果我有以下字符串列表：A = ['4-5', '3-6', '3-3', '9-0']和B = ['4-4', '4-5', '3-3', '6-9', '5-5', '3-2', '6-6', '9-9', '9,0']想要检查名单B中的A缺少了什么。A= 4-5，3-6，3-3，9-0 B= 4-4，4-5<code>e 211</code>，<code>e

问在将列表与另一个列表python进行比较时，检查列表中缺少的内容
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在将列表与另一个列表python进行比较时，检查列表中缺少的内容EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在将列表与另一个列表python进行比较时，检查列表中缺少的内容
EN