Question Comment imprimer le numéro avec des virgules comme séparateurs de milliers?


J'essaie d'imprimer un entier dans Python 2.6.1 avec des virgules comme séparateurs de milliers. Par exemple, je veux montrer le numéro 1234567 comme 1,234,567. Comment ferais-je cela? J'ai vu beaucoup d'exemples sur Google, mais je cherche la manière la plus simple pratique.

Il n'a pas besoin d'être spécifique aux paramètres régionaux pour choisir entre les points et les virgules. Je préférerais quelque chose d'aussi simple que possible.


485
2017-11-30 23:11


origine


Réponses:


Pour Python ≥ 2.7:

"{:,}".format(value)

Par Spécification du format Mini-langue,

le ',' option signale l'utilisation d'une virgule pour un séparateur de milliers. Pour un séparateur compatible avec les paramètres régionaux, utilisez le 'n' type de présentation entier à la place.


1322
2018-05-24 18:02



J'ai ça au boulot:

>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'en_US')
'en_US'
>>> locale.format("%d", 1255000, grouping=True)
'1,255,000'

Bien sûr, vous ne le faites pas avoir besoin prise en charge de l'internationalisation, mais elle est claire, concise et utilise une bibliothèque intégrée.

P.S. Ce "% d" est le formateur habituel de% -style. Vous ne pouvez avoir qu'un seul formateur, mais ce peut être tout ce dont vous avez besoin en termes de largeur de champ et de précision.

P.P.S. Si vous ne pouvez pas obtenir locale pour travailler, je suggère une version modifiée de la réponse de Mark:

def intWithCommas(x):
    if type(x) not in [type(0), type(0L)]:
        raise TypeError("Parameter must be an integer.")
    if x < 0:
        return '-' + intWithCommas(-x)
    result = ''
    while x >= 1000:
        x, r = divmod(x, 1000)
        result = ",%03d%s" % (r, result)
    return "%d%s" % (x, result)

La récursivité est utile pour le cas négatif, mais une récursivité par virgule me semble un peu excessive.


261
2017-11-30 23:22



Pour l'inefficacité et l'illisibilité, il est difficile de battre:

>>> import itertools
>>> s = '-1234567'
>>> ','.join(["%s%s%s" % (x[0], x[1] or '', x[2] or '') for x in itertools.izip_longest(s[::-1][::3], s[::-1][1::3], s[::-1][2::3])])[::-1].replace('-,','-')

89
2018-01-19 19:35



Voici le code de regroupement des paramètres régionaux après avoir supprimé les parties non pertinentes et nettoyé un peu:

(Ce qui suit ne fonctionne que pour les entiers)

def group(number):
    s = '%d' % number
    groups = []
    while s and s[-1].isdigit():
        groups.append(s[-3:])
        s = s[:-3]
    return s + ','.join(reversed(groups))

>>> group(-23432432434.34)
'-23,432,432,434'

Il y a déjà quelques bonnes réponses ici. Je veux juste ajouter ceci pour référence future. En python 2.7 il va y avoir un spécificateur de format pour le séparateur des milliers. Selon Docs python ça marche comme ça

>>> '{:20,.2f}'.format(f)
'18,446,744,073,709,551,616.00'

Dans python3.1, vous pouvez faire la même chose comme ceci:

>>> format(1234567, ',d')
'1,234,567'

89
2017-11-30 23:42



Voici un remplacement d'une ligne regex:

re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%d" % val)

Fonctionne uniquement pour les sorties intégrées:

import re
val = 1234567890
re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%d" % val)
# Returns: '1,234,567,890'

val = 1234567890.1234567890
# Returns: '1,234,567,890'

Ou pour les flottants de moins de 4 chiffres, remplacez le spécificateur de format par %.3f:

re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%.3f" % val)
# Returns: '1,234,567,890.123'

NB: Ne fonctionne pas correctement avec plus de trois chiffres décimaux car il tentera de regrouper la partie décimale:

re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%.5f" % val)
# Returns: '1,234,567,890.12,346'

Comment ça marche

Brisons-le:

re.sub(pattern, repl, string)

pattern = \
    "(\d)           # Find one digit...
     (?=            # that is followed by...
         (\d{3})+   # one or more groups of three digits...
         (?!\d)     # which are not followed by any more digits.
     )",

repl = \
    r"\1,",         # Replace that one digit by itself, followed by a comma,
                    # and continue looking for more matches later in the string.
                    # (re.sub() replaces all matches it finds in the input)

string = \
    "%d" % val      # Format the string as a decimal to begin with

31
2017-07-19 13:42



Je suis surpris que personne n'ait mentionné que vous pouvez faire cela avec des f-strings dans Python 3.6 aussi facilement:

>>> num = 10000000
>>> print(f"{num:,d}")
10,000,000

... où la partie après le deux-points est le spécificateur de format. La virgule est le caractère séparateur que vous voulez, donc f"{num:_d}" utilise des underscores au lieu d'une virgule.

Ceci est équivalent à l'utilisation format(num, ",d") pour les anciennes versions de python 3.


18
2017-07-28 07:38



Vous pouvez aussi utiliser '{:n}'.format( value ) pour une représentation locale. Je pense que c'est le moyen le plus simple pour une solution locale.

Pour plus d'informations, recherchez thousands dans Python DOC.

Pour la monnaie, vous pouvez utiliser locale.currency, en mettant le drapeau grouping:

Code

import locale

locale.setlocale( locale.LC_ALL, '' )
locale.currency( 1234567.89, grouping = True )

Sortie

'Portuguese_Brazil.1252'
'R$ 1.234.567,89'

16
2017-08-17 12:43



C'est ce que je fais pour les flotteurs. Bien que, honnêtement, je ne suis pas sûr des versions pour lesquelles il fonctionne - j'utilise 2.7:

my_number = 4385893.382939491

my_string = '{:0,.2f}'.format(my_number)

Retours: 4,385,893,38

Mise à jour: J'ai récemment rencontré un problème avec ce format (je ne pouvais pas vous dire la raison exacte), mais j'ai pu résoudre le problème en déposant la 0:

my_string = '{:,.2f}'.format(my_number)

15
2017-07-24 14:26



Je suis sûr qu'il doit y avoir une fonction de bibliothèque standard pour cela, mais c'était amusant d'essayer de l'écrire moi-même en utilisant la récursivité, alors voici ce que j'ai trouvé:

def intToStringWithCommas(x):
    if type(x) is not int and type(x) is not long:
        raise TypeError("Not an integer!")
    if x < 0:
        return '-' + intToStringWithCommas(-x)
    elif x < 1000:
        return str(x)
    else:
        return intToStringWithCommas(x / 1000) + ',' + '%03d' % (x % 1000)

Cela dit, si quelqu'un d'autre trouve une façon standard de le faire, vous devriez l'utiliser à la place.


11
2017-11-30 23:19