Question

我有以下代码：

ChangedLinks = set(NewLinkData) - set(OldLinkData)
ReplaceQueue = []
LinkUpdateTokenID = 0
for ChangedLink in ChangedLinks:
    for OldLink in OldLinkData:
        if ChangedLink[0] is OldLink[0]:
            ReplaceStrings = (OldLink[1], "<<LINK UPDATE TOKEN " + str(LinkUpdateTokenID) + ">>", ChangedLink[1])
            ReplaceQueue.append(ReplaceStrings)
    LinkUpdateTokenID += 1

ChangedLinks是一组元组，而OldLinkData是一组元组。

由于ChangedLinks和OldLinkData的长度增加，因此该方法的性能会明显下降，因为这当然存在；那只是纯粹的数学！从用户角度来看，它从有效的瞬时变为花费大量的时间（尽管少于一秒钟，至少在我的机器上）。

仅当我可以将ReplaceQueue中元组的第一个元素与{{1}中元组的第一个元素相同的对象匹配时，才需要向OldLinkData列表中添加新元素}}。（这些元组元素在各自的列表中是唯一的，例如ChangedLinks在OldLinkData[0][0]的所有其他成员中是唯一的，而OldLinkData的元素在其他列表中都是唯一的，依此类推。）我可以想到的是，要像上面的代码那样遍历每个集合/列表并比较元组元素。

有没有更有效的方法？理想情况下，我希望有一种方法可以快速构造仅OldLinkData[1][0]个成员的列表，这些成员与OldLinkData的一个成员共享第一个元素，并且顺序与ChangedLinks相同，这样我就可以并排比较列表。但是我不知道如何开始解决这个问题。

编辑：预期输入和输出的一些示例：

ChangedLinks

要清楚，这是从控制台以工作代码打印的实际输入和输出。我正在寻找一种比当前代码更有效地实现相同结果的方法。

OldLinkData: [(<Page.Page object at 0x035AF070>, ']([0])'), (<Page.Page object at 0x043FE4F0>, ']([0, 0])'), (<Page.Page object at 0x043FE590>, ']([0, 0, 0])'), (<Page.Page object at 0x043FE5B0>, ']([0, 1])')] NewLinkData: [(<Page.Page object at 0x035AF070>, ']([0])'), (<Page.Page object at 0x043FE5B0>, ']([0, 0])'), (<Page.Page object at 0x043FE4F0>, ']([0, 1])'), (<Page.Page object at 0x043FE590>, ']([0, 1, 0])')] ChangedLinks: {(<Page.Page object at 0x043FE590>, ']([0, 1, 0])'), (<Page.Page object at 0x043FE5B0>, ']([0, 0])'), (<Page.Page object at 0x043FE4F0>, ']([0, 1])')} ReplaceQueue: [(']([0, 0, 0])', '<<LINK UPDATE TOKEN 0>>', ']([0, 1, 0])'), (']([0, 1])', '<<LINK UPDATE TOKEN 1>>', ']([0, 0])'), (']([0, 0])', '<<LINK UPDATE TOKEN 2>>', ']([0, 1])')]和OldLinkData中的元组具有以下形式：

NewLinkData

该代码的目的是产生(Page.Page object at X, String)，这是旧值和新值的列表，用于替换一系列字符串（分层笔记本中的页面内容）中的子字符串。 ReplaceQueue的内容必须缩小到相同的ReplaceQueue内存对象在{{1}上有两个不同的关联“链接”（用某些markdown语法包装的整数索引路径的字符串表示）的情况下}和Page.Page。

OldLinkData和NewLinkData之间的差异是通过OldLinkData作为NewLinkData获得的，但是随后我需要在ChangedLinks中将更改后的字符串彼此关联

set(NewLinkData) - set(OldLinkData)整数只是一个中间步骤，因此我可以保证ReplaceQueue的唯一参数，而当两个对象交换链接字符串时，不会弄乱东西。

编辑：感谢@ParitoshSingh，以下代码明显更快：

LinkUpdateTokenID

Answer 1

编辑：如果用户遇到与此类似的问题，请参阅下面的更通用的解决方案。此编辑仅针对OP的此特定方案。
对于OP，可以使用可哈希值加快查找速度。对于此特定用例，请尝试id() function
警告：请牢记警告。 id函数可确保为同时存在的对象产生唯一的值，但只能保证将其链接到CPython中的内存地址，其他实现可能会有所不同。

OldLinkData = list(zip("123","abc"))
print(OldLinkData)
#[('1', 'a'), ('2', 'b'), ('3', 'c')]

NewLinkData = list(zip('1245','axyz'))
print(NewLinkData)
#[('1', 'a'), ('2', 'x'), ('4', 'y'), ('5', 'z')]


#code:

#Create a key value mapping based on the id of objects. 
OldLinkDataDict = {id(OldLink[0]): OldLink for OldLink in OldLinkData}
#{244392672200: ('1', 'a'), 244392672368: ('2', 'b'), 244420136496: ('3', 'c')}

ReplaceQueue = []
LinkUpdateTokenID = 0
for NewLink in NewLinkData:
    new_id = id(NewLink[0])
    if new_id in OldLinkDataDict: #only consider cases where NewLink exists in OldLinkData 
        if NewLink[1] != OldLinkDataDict[new_id][1]: #only when the value changes (similar to ChangedLinks)
            ReplaceStrings = (OldLinkDataDict[new_id][1],
                              "<<LINK UPDATE TOKEN " + str(LinkUpdateTokenID) + ">>",
                              NewLink[1])
            ReplaceQueue.append(ReplaceStrings)
            LinkUpdateTokenID += 1
print(ReplaceQueue)
#[('b', '<<LINK UPDATE TOKEN 0>>', 'x')]

如果您感到好奇，那么此演示仅会起作用，因为python会将int对象缓存为小数。 [-5 to 256]

通用解决方案

如果比较对象是可散列的，则可以通过将OldLinkData的数据类型更改为字典来获得非常好的收益。 Link to Docs。由于字典键是可散列的，因此字典式查询是恒定时间操作O(1)，不需要在字典中进行迭代。

#Dummy data
OldLinkData = list(zip("123","abc"))
print(OldLinkData)
#[('1', 'a'), ('2', 'b'), ('3', 'c')]

NewLinkData = list(zip('1245','axyz'))
print(NewLinkData)
#[('1', 'a'), ('2', 'x'), ('4', 'y'), ('5', 'z')]


#code:
#ChangedLinks = set(NewLinkData) - set(OldLinkData) #Remove this, set creation requires an iteration anyways   
OldLinkDataDict = dict(OldLinkData)
print(OldLinkDataDict)
#{'1': 'a', '2': 'b', '3': 'c'}

ReplaceQueue = []
LinkUpdateTokenID = 0
for NewLink in NewLinkData:
    if NewLink[0] in OldLinkDataDict: #only consider cases where NewLink exists in OldLinkData 
        if NewLink[1] != OldLinkDataDict[NewLink[0]]: #only when the value changes (similar to ChangedLinks)
            ReplaceStrings = (OldLinkDataDict[NewLink[0]],
                              "<<LINK UPDATE TOKEN " + str(LinkUpdateTokenID) + ">>",
                              NewLink[1])
            ReplaceQueue.append(ReplaceStrings)
            LinkUpdateTokenID += 1
print(ReplaceQueue)
#[('b', '<<LINK UPDATE TOKEN 0>>', 'x')]

一些比较。请注意，理想情况下，您应该只创建一次字典，但是如果您无法永久更改OldLinkData的数据类型，则我会将其保留在时间比较中。在这种情况下，您只需要根据需要创建字典以进行比较。

OldLinkData = list(zip("123","abc"))
NewLinkData = list(zip('1245','axyz'))

基线

%%timeit
ChangedLinks = set(NewLinkData) - set(OldLinkData)
ReplaceQueue = []
LinkUpdateTokenID = 0
for ChangedLink in ChangedLinks:
    for OldLink in OldLinkData:
        if ChangedLink[0] is OldLink[0]:
            ReplaceStrings = (OldLink[1], "<<LINK UPDATE TOKEN " + str(LinkUpdateTokenID) + ">>", ChangedLink[1])
            ReplaceQueue.append(ReplaceStrings)
    LinkUpdateTokenID += 1

NewCode

%%timeit
OldLinkDataDict = dict(OldLinkData)
ReplaceQueue = []
LinkUpdateTokenID = 0
for NewLink in NewLinkData:
    if NewLink[0] in OldLinkDataDict: #only consider cases where NewLink exists in OldLinkData 
        if NewLink[1] != OldLinkDataDict[NewLink[0]]: #only when the value changes (similar to ChangedLinks)
            ReplaceStrings = (OldLinkDataDict[NewLink[0]],
                              "<<LINK UPDATE TOKEN " + str(LinkUpdateTokenID) + ">>",
                              NewLink[1])
            ReplaceQueue.append(ReplaceStrings)
            LinkUpdateTokenID += 1

基线：2.16 µs ± 52.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

NewCode：1.62 µs ± 98.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

我可以基于元组的元素比较两组元组而没有嵌套循环吗？

1 个答案: