파이썬의 버전 번호 비교
https://stackoverflow.com/questions/1714027
-
19-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
나는 쓰고 싶다 cmp-두 버전 번호와 반환을 비교하는 기능 -1, 0, 또는 1 비교 가치를 기준으로합니다.
- 반품
-1버전 A가 버전 B보다 오래된 경우 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
파이썬 2.4.5 BTW를 사용하고 있습니다. (내 직장에 설치 ...).
여기에 사용할 수있는 작은 '테스트 스위트'가 있습니다.
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
해결책
문자열의 흥미롭지 않은 부분을 제거한 다음 (트레일 제로와 점)를 제거한 다음 숫자 목록을 비교하십시오.
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와 동일한 접근 방식이지만 조금 더 작습니다.
감사합니다 이 게시물:
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
다른 팁
Python 's를 사용하는 것은 어떻습니까? 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
이 품종으로 성공하려면 표준 라이브러리를 벗어나 사용해야합니다. SetUptools구문 분석 유틸리티 parse_version.
>>> from pkg_resources import parse_version
>>> parse_version('1.4') > parse_version('1.4-rc2')
True
따라서 특정 사용 사례에 따라 내장이 있는지 여부를 결정해야합니다. distutils 도구가 충분하거나 종속성으로 추가 해야하는 경우 setuptools.
~이다 재사용 이 경우 우아함을 고려 했습니까? :)
# 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))
버전 튜플을 반복 할 필요가 없습니다. 목록에 내장 된 비교 연산자와 튜플은 이미 원하는 것처럼 작동합니다. 버전 목록을 해당 길이로 확장하면됩니다. 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)
이것은 당신의 제안보다 조금 더 작습니다. 짧은 버전을 0으로 채우지 않고 분할 후 버전 목록에서 후행 0을 제거합니다.
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))
REGEX로 후행 .0 및 .00을 제거하고 분할 및 배열을 올바르게 비교하는 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)
물론 긴 줄을 신경 쓰지 않으면 1 라이너로 변환 할 수 있습니다.
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('.')]))))
하나의 라이너입니다 (가독성을 위해 분할). 읽을 수있는 것에 대해 잘 모르겠습니다 ...
목록은 파이썬에서 비슷하므로 숫자를 정수로 나타내는 문자열을 변환하면 기본 파이썬 비교를 성공적으로 사용할 수 있습니다.
그러나 나는이 접근법을 약간 연장해야했는데, 먼저 python3x를 사용하는 원인 CMP 기능은 내가 모방해야 할 필요가 없다 CMP (A, B) ~와 함께 (a> b) - (a <b).
둘째, 슬프게도, 버전 번호는 전혀 깨끗하지 않으며 모든 종류의 다른 영숫자 숯을 포함 할 수 있습니다. 함수가 순서를 말할 수없는 경우가 있습니다.
따라서 질문이 오래되고 이미 대답되었지만 생명에서 몇 분을 절약 할 수 있습니다.
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'))
외부 의존성을 끌어 당기고 싶지 않은 경우 여기에 내 시도가 있습니다 (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') >> 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') >> 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') >> compare_version('1.1', '1.10') >> 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') >> 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))
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, "="을 제외하고. 모호하기 때문에.
읽기가 가장 어렵지만 그럼에도 불구하고 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 이상은 중단을 잡아야합니다.
다른 해결책 :
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)
데비안 패키지 버전 문자열을 구문 분석하고 비교할 수 있도록이 작업을 수행했습니다. 문자 검증에 엄격하지 않다는 점에 주목하십시오.
이것은 또한 도움이 될 수 있습니다.
#!/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')
내 프로젝트에서 이것을 사용하고 있습니다.
cmp(v1.split("."), v2.split(".")) >= 0
내가 선호하는 솔루션 :
끈을 여분의 0으로 채우고 4 개의 첫 번째를 사용하는 것은 이해하기 쉽고, regex가 필요하지 않으며 Lambda는 다소 읽기 쉬운 것입니다. 나는 가독성을 위해 두 줄을 사용합니다. 우아함은 짧고 단순하기 때문입니다.
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))
이것은 내 해결책입니다 (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;
}
제휴하지 않습니다 StackOverflow
