comparer deux python chaînes qui contiennent des nombres

Mise à JOUR: je devrais l'avoir précisé plus tôt, mais pas tous les noms sont simplement des flotteurs. Par exemple, certains d'entre eux sont "préfixe" avec "YT". Ainsi, par exemple," YT1.1. donc, vous avez le même problème YT1.9 < YT1.11 doit être vrai. Je suis vraiment surpris que la chaîne échec de la comparaison....

bonjour,
cela devrait être une question assez simple mais je n'arrive pas à trouver la réponse. J'aimerais un tas de XL feuilles de calcul de par leur nom. Chacun de ces noms sont des chiffres mais de la même manière que les manuels scolaires "sections" sont numérotées, sens de l'article 4.11 vient après 4.10, qui tous deux viennent après 4,9 et 4.1. Je pensais que la simple comparaison de ces chiffres que la chaîne allait faire, mais je reçois le texte suivant:

>>> s1 = '4.11'
>>> s2 = '4.2'
>>> s1> s2
False
>>> n1 = 4.11
>>> n2 = 4.2
>>> n1 > n2
False

comment peut-on comparer ces deux valeurs telles que 4.11 est plus grande que la 4.2?

OriginalL'auteur Ramy | 2011-05-19

  1. 11

    Convertir les noms de n-uplets d'entiers et de comparer les tuples:

    def splittedname(s):
    return tuple(int(x) for x in s.split('.'))

splittedname(s1) > splittedname(s2)

    Mise à jour: vos noms, apparemment, peut contenir d'autres caractères que des chiffres, vous aurez besoin de vérifier pour ValueError et de laisser toutes les valeurs qui ne peuvent pas être convertis à ints inchangé:

    import re

def tryint(x):
    try:
        return int(x)
    except ValueError:
        return x

def splittedname(s):
    return tuple(tryint(x) for x in re.split('([0-9]+)', s))

    Pour trier une liste de noms, d'utiliser splittedname comme une fonction clé pour sorted:

    >>> names = ['YT4.11', '4.3', 'YT4.2', '4.10', 'PT2.19', 'PT2.9']
>>> sorted(names, key=splittedname)
['4.3', '4.10', 'PT2.9', 'PT2.19', 'YT4.2', 'YT4.11']
    Grande réponse. Simple et efficace.
    n'avez pas à convertir en int même.

    OriginalL'auteur Pär Wieslander

  2. 1

    Ce n'est pas une méthode intégrée, mais ça devrait marcher:

    >>> def lt(num1, num2):
...     for a, b in zip(num1.split('.'), num2.split('.')):
...         if int(a) < int(b):
...             return True
...         if int(a) > int(b):
...             return False
...     return False
... 
... lt('4.2', '4.11')
0: True

    Qui peut être nettoyé, mais il vous donne l'essentiel.

    OriginalL'auteur nmichaels

  3. 1

    Ce que vous cherchez est appelé "tri naturel". Ce qui s'oppose à "tri lexicographique". Il y a plusieurs recettes qui n'ont de ce, depuis la sortie exacte de ce que vous voulez, c'est la mise en œuvre spécifique. Une rapide recherche dans google donne ceci (note* ce n'est pas mon code, et je n'ai pas testé):

    import re

def tryint(s):
    try:
        return int(s)
    except:
        return s

def alphanum_key(s):
    """ Turn a string into a list of string and number chunks.
        "z23a" -> ["z", 23, "a"]
    """
    return [ tryint(c) for c in re.split('([0-9]+)', s) ]

def sort_nicely(l):
    """ Sort the given list in the way that humans expect.
    """
    l.sort(key=alphanum_key)

    http://nedbatchelder.com/blog/200712.html#e20071211T054956

    OriginalL'auteur Falmarri

  4. 0

    utilisation s1.split(".") pour créer une liste des éléments avant et après la virgule puis trier la liste de listes, par exemple:

    import random
sheets = list([str(x), str(y)] for x in xrange(1, 5) for y in xrange(0,99))
print sheets
#sheets in order
random.shuffle(sheets)
print sheets
#sheets out of order
sheets.sort()
print sheets
#sheets back in order

    Donc, vous la mise en œuvre pourrait être:

    #assume input sheets is a list of the worksheet names
sheets = list(x.split(".") for x in input_sheets)
sheets.sort()

    OriginalL'auteur marr75

  5. -3

    Si vous savez qu'ils sont des nombres réels [*] , il suffit de:

    >>> float(s1) > float(s2)
True

    [*] Dans le cas contraire, être prêt à gérer une soulevées ValueError.

    Incorrect. 4.11 flotteur est < 4.2, mais il devait venir par la suite (11 > 2).
    Cela suppose que les nombres sont valables flotteurs.
    Non, ceci suppose que l'OP avait posé une autre question. Valide les flotteurs est ok hypothèse.

    OriginalL'auteur Santa