Comment puis-je comparer les numéros de version en Python?

setuptools définit parse_version() . Cela implémente PEP 0440 -- Identification de Version et est également capable d'analyser les versions qui ne suivent pas la PEP. Cette fonction est utilisée par easy_install et pip pour manipuler la comparaison de version. Du docs :

a analysé la chaîne de version d'un projet telle que définie par PEP 440. La valeur retournée sera un objet qui représente la version. Ces objets peuvent être comparés les uns aux autres et triés. L'algorithme de tri est tel que défini par PEP 440 avec l'ajout que toute version qui n'est pas une version valide de PEP 440 sera considérée moins que n'importe quelle version valide de PEP 440 et les versions invalides continueront à trier en utilisant l'algorithme original.

l '"algorithme original" référencé a été défini dans des versions plus anciennes du docs, avant L'existence de PEP 440.

sémantiquement, le format est un croisement approximatif entre les classes StrictVersion et LooseVersion de distutils; si vous lui donnez des versions qui fonctionneraient avec StrictVersion , alors ils compareront de la même manière. Autrement, les comparaisons sont plus comme une forme" plus intelligente "de LooseVersion . Il est possible de créer des schémas de codage de version pathologique qui tromperont cet analyseur, mais ils devraient être très rares dans la pratique.

Le la documentation fournit quelques exemples:

si vous voulez être certain que le système de numérotation que vous avez choisi fonctionne comme vous le pensez, vous pouvez utiliser le pkg_resources.parse_version() fonction pour comparer différents numéros de version:

>>> from pkg_resources import parse_version
>>> parse_version('1.9.a.dev') == parse_version('1.9a0dev')
True
>>> parse_version('2.1-rc2') < parse_version('2.1')
True
>>> parse_version('0.6a9dev-r41475') < parse_version('0.6a9')
True

si vous n'utilisez pas d'outils setuptools, le projet packaging divise cette fonctionnalité et d'autres liées à l'emballage dans une bibliothèque séparée.

from packaging import version
version.parse('1.0.3.dev')

from pkg_resources import parse_version
parse_version('1.0.3.dev')

def versiontuple(v):
    return tuple(map(int, (v.split("."))))

>>> versiontuple("2.3.1") > versiontuple("10.1.1")
False

qu'y a-t-il de mal à transformer la chaîne de version en un tuple et à partir de là? Semble assez élégant pour moi

>>> (2,3,1) < (10,1,1)
True
>>> (2,3,1) < (10,1,1,1)
True
>>> (2,3,1,10) < (10,1,1,1)
True
>>> (10,3,1,10) < (10,1,1,1)
False
>>> (10,3,1,10) < (10,4,1,1)
True

la solution de @kindall est un exemple rapide de la qualité du code.

il y a packaging package disponible, qui vous permettra de comparer les versions selon PEP-440 , ainsi que les versions anciennes.

>>> from packaging.version import Version, LegacyVersion
>>> Version('1.1') < Version('1.2')
True
>>> Version('1.2.dev4+deadbeef') < Version('1.2')
True
>>> Version('1.2.8.5') <= Version('1.2')
False
>>> Version('1.2.8.5') <= Version('1.2.8.6')
True

support de la version Legacy:

>>> LegacyVersion('1.2.8.5-5-gdeadbeef')
<LegacyVersion('1.2.8.5-5-gdeadbeef')>

la Comparaison de l'héritage de la version avec PEP-440 version.

>>> LegacyVersion('1.2.8.5-5-gdeadbeef') < Version('1.2.8.6')
True

vous pouvez utiliser le paquet semver pour déterminer si une version satisfait à l'exigence version sémantique . Ce n'est pas la même chose que de comparer deux versions réelles, mais c'est un type de comparaison.

par exemple, la version 3.6.0+1234 devrait être la même que la version 3.6.0.

import semver
semver.match('3.6.0+1234', '==3.6.0')
# True

from packaging import version
version.parse('3.6.0+1234') == version.parse('3.6.0')
# False

from distutils.version import LooseVersion
LooseVersion('3.6.0+1234') == LooseVersion('3.6.0')
# False

Affiche ma pleine fonction basée sur la solution de Kindall. J'ai été capable de supporter tous les caractères alphanumériques mélangés avec les nombres en remplaçant chaque section de version par des zéros de tête.

bien que certainement pas aussi jolie que sa fonction one-liner, il semble bien fonctionner avec les numéros de version alphanumérique. (Assurez-vous simplement de définir la valeur zfill(#) de manière appropriée si vous avez de longues chaînes dans votre système de versioning.)

def versiontuple(v):
   filled = []
   for point in v.split("."):
      filled.append(point.zfill(8))
   return tuple(filled)

.

>>> versiontuple("10a.4.5.23-alpha") > versiontuple("2a.4.5.23-alpha")
True


>>> "10a.4.5.23-alpha" > "2a.4.5.23-alpha"
False

je vais aller plus pour l'option touple, faire un test, en utilisant LooseVersion, Je ne reçois dans mon test le deuxième plus grand, (pourrait faire quelque chose de mal puisque c'est ma première fois en utilisant cette bibliothèque)

import itertools
from distutils.version import LooseVersion, StrictVersion

lista_de_frameworks = ["1.1.1", "1.2.5", "10.5.2", "3.4.5"]

for a, b in itertools.combinations(lista_de_frameworks, 2):
    if LooseVersion(a) < LooseVersion(b):
        big = b
print big

list_test = []
for a in lista_de_frameworks:
    list_test.append( tuple(map(int, (a.split(".")))))

print max(list_test)

et voilà ce que j'ai eu:

3.4.5 avec vrac

(10, 5, 2) et avec les perruques