【问题标题】:Checking for version updates in two large lists of names and versions检查两个大型名称和版本列表中的版本更新
【发布时间】:2017-06-02 02:38:37
【问题描述】:

我有两个非常大的软件包列表及其版本,我正在尝试比较它们以确定是否有更高版本的软件包。我的数据示例:

listOne = ['autoconf-2.69-4',  'b43-fwcutter-019-1', 'binutils-2.28.0-3']
listTwo = ['autoconf-2.69-4', 'automake-1.16-1',  'binutils-2.29.0-1']

现在我需要找到比 listOne 版本更高的包。在上面的例子中,只有 binutils 符合条件。

这些列表是有序的,但每个列表都有自己唯一的包、相同版本的共享包,以及同名但版本不同的包。这些就是我要找的。需要最终列表的顺序,并且包必须保持其当前的命名方案。

我目前的代码如下:

listOne = ['autoconf-2.69-4',  'b43-fwcutter-019-1', 'binutils-2.28.0-3']
listTwo = ['autoconf-2.69-4', 'automake-1.16-1',  'binutils-2.29.0-1']

uniqPackages = sorted(list(set(listTwoPackages) - set(listOnePackages)))

for package in uniqPackages:
    for packageFull in listOne:
        if packageFull.rsplit("-", 2)[0] == package.rsplit("-", 2)[0]:
            versionValue = compareVersions(packageFull.rsplit("-", 2)[1] + "-" + packageFull.rsplit("-", 2)[2], \
                package.rsplit("-", 2)[1] + "-" + package.rsplit("-", 2)[2])
            if versionValue:
                print(package.rsplit("-", 2)[0] + "-" + package.rsplit("-", 2)[1] + "-" + package.rsplit("-", 2)[2])

函数compareVersions 是一个自定义函数,如果第二个版本比第一个值新,它将返回 True。有些是低版本的,我不想要。

这段代码有点笨拙,而且相当慢,因为我的列表非常庞大。无论如何我可以加快这个比较过程吗?

提前致谢。

【问题讨论】:

    标签: python performance python-3.x optimization package-managers


    【解决方案1】:

    你做错了: 对于一个列表中的每个包,您都在迭代整个第二个。 复杂度为M x N (M, N = len(first), len(second))。

    鉴于包是有序的,您可以使用合并算法中的迭代(在第一个或第二个数组上进行步进,无论哪个更小,打印结果)。因此,复杂性将是线性的 (M + N),而不是平方。

    只是一个比较提示 - 我建议查看标准库 distutils.version.LooseVersion

    可以从任意字符串实例化,然后进行比较:

    LooseVersion('19.1-alpha') < LooseVersion('19.3')
    LooseVersion('19.10-alpha') > LooseVersion('19.3')
    

    Some docs over the internet

    至于其他小优化,注意有很多重复的同值计算,比如.rsplit调用,最好引入一个变量并复用。

    这是我将如何实现它:

    from distutils.version import LooseVersion
    
    def compare_versions(a, b):
        return LooseVersion(a) < LooseVersion(b)
    
    i, j = 0, 0
    M, N = len(first_packages), len(second_packages)
    
    while i < M and j < N:
        package_f, version_f, minor_f = first_packages[i].rsplit('-', 2)
        package_s, version_s, minor_s = second_packages[j].rsplit('-', 2)
    
        if package_f == package_s:
            if compare_versions(
                '-'.join((version_f, minor_f)),
                '-'.join((version_s, minor_s))
            ):
                print(second_packages[j])
            i += 1
            j += 1
        else:
            if package_f < package_s:
                i += 1
            else:
                j += 1
    

    另一个使用heapq模块的实现,可能会更快:

    import heapq
    last = ''
    name = lambda p: p.rsplit('-', 2)[0]
    version = lambda p: '-'.join(p.rsplit('-', 2)[-2:])
    for pckg in heapq.merge(first_packages, second_packages, key=name):
        if last and name(last) == name(pckg) and compareVersions(
            version(last), version(pckg)
        ):
            print(pckg)
        else:
            last = pckg
    

    【讨论】:

    • 我真的很喜欢这种方法,但由于我不知道的原因,这实际上需要两倍多一点的时间。在我当前的代码下,它需要 0m46.053s,而在你的代码下,它需要 2m0.250s... 然而,排序的想法比我的嵌套循环更具吸引力。
    • 我找不到它可以变慢的任何原因......这可能是因为不同的 compareVersions ? LooseVersion 处理了很多情况,所以不是最简单的实例化和比较... 也可能是因为uniquePackages 比较小...
    猜你喜欢
    • 1970-01-01
    • 2021-10-22
    • 1970-01-01
    • 2017-02-27
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2018-11-17
    相关资源
    最近更新 更多