Сравнение номеров версий в Python

98

Я хочу написать cmp-like функцию , которая сравнивает два номера версии и возвращается -1, 0или на 1основе их сравнении valuses.

  • Вернуть, -1если версия A старше версии B
  • Вернуть, 0если версии A и B эквивалентны
  • Вернуть, 1если версия A новее, чем версия B

Предполагается, что каждый подраздел следует интерпретировать как число, поэтому 1.10> 1.1.

Желаемые функциональные выходы:

mycmp('1.0', '1') == 0
mycmp('1.0.0', '1') == 0
mycmp('1', '1.0.0.1') == -1
mycmp('12.10', '11.0.0.0.0') == 1
...

И вот моя реализация, открытая для улучшения:

def mycmp(version1, version2):
    parts1 = [int(x) for x in version1.split('.')]
    parts2 = [int(x) for x in version2.split('.')]

    # fill up the shorter version with zeros ...
    lendiff = len(parts1) - len(parts2)
    if lendiff > 0:
        parts2.extend([0] * lendiff)
    elif lendiff < 0:
        parts1.extend([0] * (-lendiff))

    for i, p in enumerate(parts1):
        ret = cmp(p, parts2[i])
        if ret: return ret
    return 0

Кстати, я использую Python 2.4.5. (установлен на моем рабочем месте ...).

Вот небольшой набор тестов, который вы можете использовать

assert mycmp('1', '2') == -1
assert mycmp('2', '1') == 1
assert mycmp('1', '1') == 0
assert mycmp('1.0', '1') == 0
assert mycmp('1', '1.000') == 0
assert mycmp('12.01', '12.1') == 0
assert mycmp('13.0.1', '13.00.02') == -1
assert mycmp('1.1.1.1', '1.1.1.1') == 0
assert mycmp('1.1.1.2', '1.1.1.1') == 1
assert mycmp('1.1.3', '1.1.3.000') == 0
assert mycmp('3.1.1.0', '3.1.2.10') == -1
assert mycmp('1.1', '1.10') == -1
Йоханнес Чарра
источник
Не ответ, а предложение - возможно, стоит реализовать алгоритм Debian для сравнения номеров версий (в основном, чередование нечисловых и числовых частей). Алгоритм описан здесь (начиная с «Строки сравниваются слева направо»).
hobbs
Бларф. Подмножество уценки, поддерживаемое в комментариях, никогда меня не смущает. Ссылка все равно работает, даже если выглядит глупо.
hobbs
В случае, если будущим читателям это понадобится для анализа версии пользовательского агента, я рекомендую специальную библиотеку, так как историческая вариация слишком велика.
Джеймс Бродхед
2
Возможный дубликат строк сравнения версий в Python
John Y,
1
Несмотря на то, что вопрос здесь более старый, похоже, этот другой вопрос был помазан как канонический, так как многие, многие вопросы закрыты как дубликаты этого.
John Y

Ответы:

37

Удалите неинтересную часть строки (завершающие нули и точки), а затем сравните списки чисел.

import re

def mycmp(version1, version2):
    def normalize(v):
        return [int(x) for x in re.sub(r'(\.0+)*$','', v).split(".")]
    return cmp(normalize(version1), normalize(version2))

Это тот же подход, что и Pär Wieslander, но немного более компактный:

Вот несколько тестов, благодаря « Как сравнить две строки в формате версии, разделенной точкой в ​​Bash? »:

assert mycmp("1", "1") == 0
assert mycmp("2.1", "2.2") < 0
assert mycmp("3.0.4.10", "3.0.4.2") > 0
assert mycmp("4.08", "4.08.01") < 0
assert mycmp("3.2.1.9.8144", "3.2") > 0
assert mycmp("3.2", "3.2.1.9.8144") < 0
assert mycmp("1.2", "2.1") < 0
assert mycmp("2.1", "1.2") > 0
assert mycmp("5.6.7", "5.6.7") == 0
assert mycmp("1.01.1", "1.1.1") == 0
assert mycmp("1.1.1", "1.01.1") == 0
assert mycmp("1", "1.0") == 0
assert mycmp("1.0", "1") == 0
assert mycmp("1.0", "1.0.1") < 0
assert mycmp("1.0.1", "1.0") > 0
assert mycmp("1.0.2.0", "1.0.2") == 0
гнуд
источник
2
Боюсь, что это не сработает, rstrip(".0")поменяется с ".10" на ".1" в "1.0.10".
RedGlyph
Извините, но с вашей функцией: mycmp ('1.1', '1.10') == 0
Johannes Charra
С использованием регулярного выражения проблема, упомянутая выше, решена.
gnud
Теперь вы объединили все хорошие идеи от других в свое решение ... :-P тем не менее, это в значительной степени то, что я бы сделал в конце концов. Я приму этот ответ. Спасибо всем
Йоханнес Чарра
2
Обратите внимание, что cmp () был удален в Python 3: docs.python.org/3.0/whatsnew/3.0.html#ordering-comparisons
Доминик Клил,
279

Как насчет использования Python distutils.version.StrictVersion?

>>> from distutils.version import StrictVersion
>>> StrictVersion('10.4.10') > StrictVersion('10.4.9')
True

Итак, для вашей cmpфункции:

>>> cmp = lambda x, y: StrictVersion(x).__cmp__(y)
>>> cmp("10.4.10", "10.4.11")
-1

Если вы хотите сравнить более сложные номера версий, вам distutils.version.LooseVersionбудет полезнее сравнивать только те же типы.

>>> from distutils.version import LooseVersion, StrictVersion
>>> LooseVersion('1.4c3') > LooseVersion('1.3')
True
>>> LooseVersion('1.4c3') > StrictVersion('1.3')  # different types
False

LooseVersion не самый умный инструмент, и его легко обмануть:

>>> LooseVersion('1.4') > LooseVersion('1.4-rc1')
False

Чтобы добиться успеха с этой породой, вам нужно выйти за рамки стандартной библиотеки и использовать утилиту синтаксического анализа setuptoolsparse_version .

>>> from pkg_resources import parse_version
>>> parse_version('1.4') > parse_version('1.4-rc2')
True

Таким образом, в зависимости от вашего конкретного варианта использования вам необходимо решить, достаточно ли встроенных distutilsинструментов или необходимо добавить их в качестве зависимости setuptools.

bradley.ayers
источник
2
кажется имеет смысл просто использовать то, что уже есть :)
Патрик Вольф
2
Ницца! Вы поняли это, прочитав первоисточник? Я нигде не могу найти документацию по distutils.version: - /
Адам Спирс,
3
Каждый раз, когда вы не можете найти документацию, попробуйте импортировать пакет и использовать help ().
rspeed
13
Имейте в виду, что это работает StrictVersion ТОЛЬКО с версией с тремя номерами. Он не подходит для таких вещей, как 0.4.3.6!
abergmeier
6
Каждый экземпляр distributeв этом ответе следует заменить на setuptools, который идет в комплекте с pkg_resourcesпакетом и с тех пор ... как никогда . Точно так же это официальная документация для pkg_resources.parse_version()функции, входящей в комплект setuptools.
Сесил Карри,
30

Считается ли повторное использование элегантностью в данном случае? :)

# pkg_resources is in setuptools
# See http://peak.telecommunity.com/DevCenter/PkgResources#parsing-utilities
def mycmp(a, b):
    from pkg_resources import parse_version as V
    return cmp(V(a),V(b))
конни
источник
7
Хм, это не так элегантно, когда вы ссылаетесь на что-то вне стандартной библиотеки, не объясняя, где это взять. Я отправил правку, чтобы включить URL. Лично я предпочитаю использовать distutils - кажется, не стоит тратить силы на использование стороннего программного обеспечения для такой простой задачи.
Адам Спирс,
1
@ adam-spiers wut? Вы хоть комментарий читали? pkg_resourcesэто setuptoolsупакованный пакет. Поскольку setuptoolsфактически является обязательным для всех установок Python, pkg_resourcesон фактически доступен везде. Тем не менее, distutils.versionподпакет также полезен, хотя и значительно менее интеллектуален, чем pkg_resources.parse_version()функция более высокого уровня . То, что вам следует использовать, зависит от того, какую степень безумия вы ожидаете в строках версии.
Сесил Карри,
@CecilCurry Да, конечно, я прочитал комментарий (ary), поэтому я отредактировал его, чтобы улучшить, а затем заявил, что у меня есть. По-видимому, вы не возражаете с моим утверждением, setuptoolsвыходящим за рамки стандартной библиотеки, а вместо этого с моим заявленным предпочтением distutils в данном случае . Итак, что именно вы имеете в виду под «фактически обязательным», и не могли бы вы представить доказательства того, что он был «фактически обязательным» 4,5 года назад, когда я написал этот комментарий?
Адам Спирс,
12

Нет необходимости перебирать кортежи версий. Встроенный оператор сравнения списков и кортежей уже работает точно так, как вы этого хотите. Вам просто нужно расширить списки версий до соответствующей длины. В python 2.6 вы можете использовать izip_longest для заполнения последовательностей.

from itertools import izip_longest
def version_cmp(v1, v2):
    parts1, parts2 = [map(int, v.split('.')) for v in [v1, v2]]
    parts1, parts2 = zip(*izip_longest(parts1, parts2, fillvalue=0))
    return cmp(parts1, parts2)

В более ранних версиях требуется взлом карты.

def version_cmp(v1, v2):
    parts1, parts2 = [map(int, v.split('.')) for v in [v1, v2]]
    parts1, parts2 = zip(*map(lambda p1,p2: (p1 or 0, p2 or 0), parts1, parts2))
    return cmp(parts1, parts2)
Муравьи Аасма
источник
Классно, но трудно понять тому, кто не умеет читать код как прозу. :) Что ж, я полагаю, вы можете только сократить решение за счет удобочитаемости ...
Йоханнес Чарра
10

Это немного компактнее, чем ваше предложение. Вместо того, чтобы заполнять более короткую версию нулями, я удаляю конечные нули из списков версий после разделения.

def normalize_version(v):
    parts = [int(x) for x in v.split(".")]
    while parts[-1] == 0:
        parts.pop()
    return parts

def mycmp(v1, v2):
    return cmp(normalize_version(v1), normalize_version(v2))
Пэр Вислендер
источник
Хороший, спасибо. Но я все еще надеюсь на одно- или двухстрочный ...;)
Йоханнес Чарра
4
+1 @jellybean: двухстрочный код не всегда лучше подходит для обслуживания и удобочитаемости, это очень четкий и компактный код одновременно, кроме того, вы можете повторно использовать его mycmpдля других целей в своем коде, если он вам понадобится.
RedGlyph
@RedGlyph: Вы правы. Надо было сказать «читабельный двухстрочный». :)
Johannes Charra
Привет @ Pär Wieslander, когда я использую это решение для решения той же проблемы в проблеме Leetcode, я получаю ошибку в цикле while, говорящую «индекс списка вне допустимого диапазона». Не могли бы вы помочь, почему это происходит? Вот проблема: leetcode.com/explore/interview/card/amazon/76/array-and-strings/…
YouHaveaBigEgo
7

Удалите трейлинг .0и .00с помощью регулярного выражения splitи используйте cmpфункцию, которая правильно сравнивает массивы:

def mycmp(v1,v2):
 c1=map(int,re.sub('(\.0+)+\Z','',v1).split('.'))
 c2=map(int,re.sub('(\.0+)+\Z','',v2).split('.'))
 return cmp(c1,c2)

И, конечно, вы можете преобразовать его в однострочник, если не возражаете против длинных строк.

ю_ша
источник
2
def compare_version(v1, v2):
    return cmp(*tuple(zip(*map(lambda x, y: (x or 0, y or 0), 
           [int(x) for x in v1.split('.')], [int(y) for y in v2.split('.')]))))

Это однострочный (разделенный для удобочитаемости). Не уверен в удобочитаемости ...

Mavnn
источник
1
Да! И уменьшился еще больше ( tupleкстати, это не нужно):cmp(*zip(*map(lambda x,y:(x or 0,y or 0), map(int,v1.split('.')), map(int,v2.split('.')) )))
Paul
2
from distutils.version import StrictVersion
def version_compare(v1, v2, op=None):
    _map = {
        '<': [-1],
        'lt': [-1],
        '<=': [-1, 0],
        'le': [-1, 0],
        '>': [1],
        'gt': [1],
        '>=': [1, 0],
        'ge': [1, 0],
        '==': [0],
        'eq': [0],
        '!=': [-1, 1],
        'ne': [-1, 1],
        '<>': [-1, 1]
    }
    v1 = StrictVersion(v1)
    v2 = StrictVersion(v2)
    result = cmp(v1, v2)
    if op:
        assert op in _map.keys()
        return result in _map[op]
    return result

Реализован для php version_compare, кроме "=". Потому что это неоднозначно.

Райан Фау
источник
2

Списки сопоставимы в Python, поэтому, если кто-то преобразует строки, представляющие числа, в целые числа, можно с успехом использовать базовое сравнение Python.

Мне нужно было немного расширить этот подход, потому что я использую Python3x, где cmpфункция больше не существует. Я должен был подражать cmp(a,b)с (a > b) - (a < b). Кроме того, номера версий не такие уж чистые и могут содержать всевозможные другие буквенно-цифровые символы. Бывают случаи, когда функция не может определить порядок, поэтому возвращается False(см. Первый пример).

Я отправляю это, даже если вопрос старый и на него уже дан ответ, потому что это может сэкономить несколько минут в чьей-то жизни.

import re

def _preprocess(v, separator, ignorecase):
    if ignorecase: v = v.lower()
    return [int(x) if x.isdigit() else [int(y) if y.isdigit() else y for y in re.findall("\d+|[a-zA-Z]+", x)] for x in v.split(separator)]

def compare(a, b, separator = '.', ignorecase = True):
    a = _preprocess(a, separator, ignorecase)
    b = _preprocess(b, separator, ignorecase)
    try:
        return (a > b) - (a < b)
    except:
        return False

print(compare('1.0', 'beta13'))    
print(compare('1.1.2', '1.1.2'))
print(compare('1.2.2', '1.1.2'))
print(compare('1.1.beta1', '1.1.beta2'))
Саньи
источник
2

Если вы не хотите использовать внешнюю зависимость, вот моя попытка, написанная для Python 3.x.

rc, rel(и, возможно, можно было бы добавить c), рассматриваются как «кандидат на выпуск» и делят номер версии на две части, а в случае отсутствия значение второй части высокое (999). Остальные буквы производят разделение и обрабатываются как субчисла через код base-36.

import re
from itertools import chain
def compare_version(version1,version2):
    '''compares two version numbers
    >>> compare_version('1', '2') < 0
    True
    >>> compare_version('2', '1') > 0
    True
    >>> compare_version('1', '1') == 0
    True
    >>> compare_version('1.0', '1') == 0
    True
    >>> compare_version('1', '1.000') == 0
    True
    >>> compare_version('12.01', '12.1') == 0
    True
    >>> compare_version('13.0.1', '13.00.02') <0
    True
    >>> compare_version('1.1.1.1', '1.1.1.1') == 0
    True
    >>> compare_version('1.1.1.2', '1.1.1.1') >0
    True
    >>> compare_version('1.1.3', '1.1.3.000') == 0
    True
    >>> compare_version('3.1.1.0', '3.1.2.10') <0
    True
    >>> compare_version('1.1', '1.10') <0
    True
    >>> compare_version('1.1.2','1.1.2') == 0
    True
    >>> compare_version('1.1.2','1.1.1') > 0
    True
    >>> compare_version('1.2','1.1.1') > 0
    True
    >>> compare_version('1.1.1-rc2','1.1.1-rc1') > 0
    True
    >>> compare_version('1.1.1a-rc2','1.1.1a-rc1') > 0
    True
    >>> compare_version('1.1.10-rc1','1.1.1a-rc2') > 0
    True
    >>> compare_version('1.1.1a-rc2','1.1.2-rc1') < 0
    True
    >>> compare_version('1.11','1.10.9') > 0
    True
    >>> compare_version('1.4','1.4-rc1') > 0
    True
    >>> compare_version('1.4c3','1.3') > 0
    True
    >>> compare_version('2.8.7rel.2','2.8.7rel.1') > 0
    True
    >>> compare_version('2.8.7.1rel.2','2.8.7rel.1') > 0
    True

    '''
    chn = lambda x:chain.from_iterable(x)
    def split_chrs(strings,chars):
        for ch in chars:
            strings = chn( [e.split(ch) for e in strings] )
        return strings
    split_digit_char=lambda x:[s for s in re.split(r'([a-zA-Z]+)',x) if len(s)>0]
    splt = lambda x:[split_digit_char(y) for y in split_chrs([x],'.-_')]
    def pad(c1,c2,f='0'):
        while len(c1) > len(c2): c2+=[f]
        while len(c2) > len(c1): c1+=[f]
    def base_code(ints,base):
        res=0
        for i in ints:
            res=base*res+i
        return res
    ABS = lambda lst: [abs(x) for x in lst]
    def cmp(v1,v2):
        c1 = splt(v1)
        c2 = splt(v2)
        pad(c1,c2,['0'])
        for i in range(len(c1)): pad(c1[i],c2[i])
        cc1 = [int(c,36) for c in chn(c1)]
        cc2 = [int(c,36) for c in chn(c2)]
        maxint = max(ABS(cc1+cc2))+1
        return base_code(cc1,maxint) - base_code(cc2,maxint)
    v_main_1, v_sub_1 = version1,'999'
    v_main_2, v_sub_2 = version2,'999'
    try:
        v_main_1, v_sub_1 = tuple(re.split('rel|rc',version1))
    except:
        pass
    try:
        v_main_2, v_sub_2 = tuple(re.split('rel|rc',version2))
    except:
        pass
    cmp_res=[cmp(v_main_1,v_main_2),cmp(v_sub_1,v_sub_2)]
    res = base_code(cmp_res,max(ABS(cmp_res))+1)
    return res


import random
from functools import cmp_to_key
random.shuffle(versions)
versions.sort(key=cmp_to_key(compare_version))
Роланд Пунтайер
источник
1

Самое трудное для чтения решение, но все же однострочное! и использовать итераторы для быстрой работы.

next((c for c in imap(lambda x,y:cmp(int(x or 0),int(y or 0)),
            v1.split('.'),v2.split('.')) if c), 0)

это для Python2.6 и 3. + btw, Python 2.5 и старше должны улавливать StopIteration.

Павел
источник
1

Я сделал это, чтобы иметь возможность анализировать и сравнивать строку версии пакета Debian. Обратите внимание, что проверка символов не является строгой.

Это также может быть полезно:

#!/usr/bin/env python

# Read <https://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Version> for further informations.

class CommonVersion(object):
    def __init__(self, version_string):
        self.version_string = version_string
        self.tags = []
        self.parse()

    def parse(self):
        parts = self.version_string.split('~')
        self.version_string = parts[0]
        if len(parts) > 1:
            self.tags = parts[1:]


    def __lt__(self, other):
        if self.version_string < other.version_string:
            return True
        for index, tag in enumerate(self.tags):
            if index not in other.tags:
                return True
            if self.tags[index] < other.tags[index]:
                return True

    @staticmethod
    def create(version_string):
        return UpstreamVersion(version_string)

class UpstreamVersion(CommonVersion):
    pass

class DebianMaintainerVersion(CommonVersion):
    pass

class CompoundDebianVersion(object):
    def __init__(self, epoch, upstream_version, debian_version):
        self.epoch = epoch
        self.upstream_version = UpstreamVersion.create(upstream_version)
        self.debian_version = DebianMaintainerVersion.create(debian_version)

    @staticmethod
    def create(version_string):
        version_string = version_string.strip()
        epoch = 0
        upstream_version = None
        debian_version = '0'

        epoch_check = version_string.split(':')
        if epoch_check[0].isdigit():
            epoch = int(epoch_check[0])
            version_string = ':'.join(epoch_check[1:])
        debian_version_check = version_string.split('-')
        if len(debian_version_check) > 1:
            debian_version = debian_version_check[-1]
            version_string = '-'.join(debian_version_check[0:-1])

        upstream_version = version_string

        return CompoundDebianVersion(epoch, upstream_version, debian_version)

    def __repr__(self):
        return '{} {}'.format(self.__class__.__name__, vars(self))

    def __lt__(self, other):
        if self.epoch < other.epoch:
            return True
        if self.upstream_version < other.upstream_version:
            return True
        if self.debian_version < other.debian_version:
            return True
        return False


if __name__ == '__main__':
    def lt(a, b):
        assert(CompoundDebianVersion.create(a) < CompoundDebianVersion.create(b))

    # test epoch
    lt('1:44.5.6', '2:44.5.6')
    lt('1:44.5.6', '1:44.5.7')
    lt('1:44.5.6', '1:44.5.7')
    lt('1:44.5.6', '2:44.5.6')
    lt('  44.5.6', '1:44.5.6')

    # test upstream version (plus tags)
    lt('1.2.3~rc7',          '1.2.3')
    lt('1.2.3~rc1',          '1.2.3~rc2')
    lt('1.2.3~rc1~nightly1', '1.2.3~rc1')
    lt('1.2.3~rc1~nightly2', '1.2.3~rc1')
    lt('1.2.3~rc1~nightly1', '1.2.3~rc1~nightly2')
    lt('1.2.3~rc1~nightly1', '1.2.3~rc2~nightly1')

    # test debian maintainer version
    lt('44.5.6-lts1', '44.5.6-lts12')
    lt('44.5.6-lts1', '44.5.7-lts1')
    lt('44.5.6-lts1', '44.5.7-lts2')
    lt('44.5.6-lts1', '44.5.6-lts2')
    lt('44.5.6-lts1', '44.5.6-lts2')
    lt('44.5.6',      '44.5.6-lts1')
Пиус Рэдер
источник
0

Другое решение:

def mycmp(v1, v2):
    import itertools as it
    f = lambda v: list(it.dropwhile(lambda x: x == 0, map(int, v.split('.'))[::-1]))[::-1]
    return cmp(f(v1), f(v2))

Можно использовать и так:

import itertools as it
f = lambda v: list(it.dropwhile(lambda x: x == 0, map(int, v.split('.'))[::-1]))[::-1]
f(v1) <  f(v2)
f(v1) == f(v2)
f(v1) >  f(v2)
педиатр
источник
0

Я использую это в своем проекте:

cmp(v1.split("."), v2.split(".")) >= 0
Кейрр Перино
источник
0

Спустя годы, но этот вопрос все еще остается на первом месте.

Вот моя функция сортировки версий. Он разбивает версию на числовые и не числовые разделы. Числа сравниваются как intостальные str(как части элементов списка).

def sort_version_2(data):
    def key(n):
        a = re.split(r'(\d+)', n)
        a[1::2] = map(int, a[1::2])
        return a
    return sorted(data, key=lambda n: key(n))

Вы можете использовать функцию keyкак своего рода настраиваемый Versionтип с операторами сравнения. Если вы действительно хотите использовать, cmpвы можете сделать это, как в этом примере: https://stackoverflow.com/a/22490617/9935708

def Version(s):
    s = re.sub(r'(\.0*)*$', '', s)  # to avoid ".0" at end
    a = re.split(r'(\d+)', s)
    a[1::2] = map(int, a[1::2])
    return a

def mycmp(a, b):
    a, b = Version(a), Version(b)
    return (a > b) - (a < b)  # DSM's answer

Набор тестов пройден.

Райссон
источник
-1

Мое предпочтительное решение:

Добавление в строку дополнительных нулей и простое использование четырех первых легко понять, не требует никакого регулярного выражения, а лямбда более или менее читается. Я использую две строки для удобства чтения, для меня элегантность коротка и проста.

def mycmp(version1,version2):
  tup = lambda x: [int(y) for y in (x+'.0.0.0.0').split('.')][:4]
  return cmp(tup(version1),tup(version2))
дарамарак
источник
-1

Это мое решение (написано на C, извините). Я надеюсь ты сочтёшь это полезным

int compare_versions(const char *s1, const char *s2) {
    while(*s1 && *s2) {
        if(isdigit(*s1) && isdigit(*s2)) {
            /* compare as two decimal integers */
            int s1_i = strtol(s1, &s1, 10);
            int s2_i = strtol(s2, &s2, 10);

            if(s1_i != s2_i) return s1_i - s2_i;
        } else {
            /* compare as two strings */
            while(*s1 && !isdigit(*s1) && *s2 == *s1) {
                s1++;
                s2++;
            }

            int s1_i = isdigit(*s1) ? 0 : *s1;
            int s2_i = isdigit(*s2) ? 0 : *s2;

            if(s1_i != s2_i) return s1_i - s2_i;
        }
    }

    return 0;
}
e_asphyx
источник