Ik probeer een geheel getal in Python 2.6.1af te drukken met komma’s als scheidingstekens voor duizendtallen. Ik wil bijvoorbeeld het nummer 1234567weergeven als 1,234,567. Hoe zou ik dit gaan doen? Ik heb veel voorbeelden op Google gezien, maar ik ben op zoek naar de eenvoudigste praktische manier.

Het hoeft niet landspecifiek te zijn om te kiezen tussen punten en komma’s. Ik heb liever iets zo eenvoudig als redelijkerwijs mogelijk is.

Antwoord 1, autoriteit 100%

Lokaal niet op de hoogte

'{:,}'.format(value)  # For Python ≥2.7
f'{value:,}'  # For Python ≥3.6

Lokaal bewust

import locale
locale.setlocale(locale.LC_ALL, '')  # Use '' for auto, or force e.g. to 'en_US.UTF-8'
'{:n}'.format(value)  # For Python ≥2.7
f'{value:n}'  # For Python ≥3.6

Referentie

Per Formaatspecificatie minitaal,

De optie ','geeft het gebruik van een komma aan voor een scheidingsteken voor duizendtallen. Gebruik in plaats daarvan het presentatietype 'n'integer voor een locale-bewust scheidingsteken.

Antwoord 2, autoriteit 15%

Ik heb dit laten werken:

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

Natuurlijk, u heeft geenondersteuning voor internationalisering nodig, maar het is duidelijk, beknopt en maakt gebruik van een ingebouwde bibliotheek.

P.S. Dat “% D” de gebruikelijke% -style-formatter is. Je kunt maar één formatter hebben, maar het kan zijn wat je nodig hebt in termen van veldbreedte en precisie-instellingen.

p.p.s. Als u niet kunt krijgen localeom te werken, zou ik een gewijzigde versie van het antwoord van Markeren voorstellen:

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)

Recursie is handig voor het negatieve geval, maar één recursie per komma lijkt mij een beetje overdreven.

3, Autoriteit 10%

Ik ben verrast dat niemand heeft vermeld dat je dit kunt doen met F-strings in Python 3.6+ zo eenvoudig als dit:

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

… waar het deel na de dikke darm is de indelingspeciferie. De komma is het gewenste scheidingsteken, dus f"{num:_}"gebruikt onderstrepingstekens in plaats van een komma. Alleen “,” en “_” is mogelijk om met deze methode te gebruiken.

Dit is equivalent van het gebruik van format(num, ",")voor oudere versies van Python 3.

4, Autoriteit 7%

Voor inefficiëntie en onredelijkheid is het moeilijk om te verslaan:

>>> 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('-,','-')

5, Autoriteit 5%

Hier is de Locale-groepscode na het verwijderen van irrelevante onderdelen en het schoonmaken van een beetje:

(het volgende alleen werkt voor gehele getallen)

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'

Er zijn al een goede antwoorden hier in. Ik wil dit gewoon toevoegen voor toekomstige referentie. In Python 2.7 wordt een formaatspecificator voor duizenden scheider. Volgens python docs Het werkt als deze

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

In Python3.1 kunt u hetzelfde doen als deze:

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

6, Autoriteit 2%

Hier is een One-Line Regex-vervanging:

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

Werkt alleen voor inegrale uitgangen:

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'

of voor drijvers met minder dan 4 cijfers, wijzig het formaatspecificator voor %.3f:

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

NB:werkt niet correct met meer dan drie decimale cijfers omdat het zal proberen het decimale deel te groeperen:

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

Hoe het werkt

Laten we het opsplitsen:

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

Antwoord 7, autoriteit 2%

Dit is wat ik doe voor drijvers. Hoewel ik eerlijk gezegd niet zeker weet voor welke versies het werkt – ik gebruik 2.7:

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

Retouren: 4.385.893,38

Update: ik had onlangs een probleem met deze indeling (kon je de exacte reden niet vertellen), maar ik heb het kunnen oplossen door de 0:

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

Antwoord 8

U kunt ook '{:n}'.format( value )gebruiken voor een landinstelling. Ik denk dat dit de eenvoudigste manier is voor een lokale oplossing.

Zoek voor meer informatie naar thousandsin Python-DOC.

Voor valuta kunt u locale.currencygebruiken en de vlag groupinginstellen:

Code

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

Uitvoer

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

Antwoord 9

Het antwoord van Ian Schneider iets uitbreiden:

Als u een aangepast scheidingsteken voor duizendtallen wilt gebruiken, is de eenvoudigste oplossing:

'{:,}'.format(value).replace(',', your_custom_thousands_separator)

Voorbeelden

'{:,.2f}'.format(123456789.012345).replace(',', ' ')

Als je de Duitse representatie zo wilt, wordt het een beetje ingewikkelder:

('{:,.2f}'.format(123456789.012345)
          .replace(',', ' ')  # 'save' the thousands separators 
          .replace('.', ',')  # dot to comma
          .replace(' ', '.')) # thousand separators to dot

Antwoord 10

Ik weet zeker dat hier een standaard bibliotheekfunctie voor moet zijn, maar het was leuk om te proberen het zelf te schrijven met behulp van recursie, dus dit is wat ik bedacht:

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)

Dat gezegd hebbende, als iemand anders een standaardmanier vindt om het te doen, moet u die in plaats daarvan gebruiken.

Antwoord 11

Van de opmerkingennaar activestate recept 498181Ik heb dit herwerkt:

import re
def thous(x, sep=',', dot='.'):
    num, _, frac = str(x).partition(dot)
    num = re.sub(r'(\d{3})(?=\d)', r'\1'+sep, num[::-1])[::-1]
    if frac:
        num += dot + frac
    return num

Het gebruikt de functie voor reguliere expressies: lookaheaddwz (?=\d)om ervoor te zorgen dat alleen groepen van drie cijfers met een cijfer ‘na’ een komma krijgen. Ik zeg ‘na’ omdat de string op dit punt omgekeerd is.

[::-1]draait gewoon een string om.

Antwoord 12

Het geaccepteerde antwoord is prima, maar ik geef eigenlijk de voorkeur aan format(number,','). Makkelijker voor mij om te interpreteren en te onthouden.

https://docs.python.org/3/library/functions. html#format

Antwoord 13

Python 3

—

gehele getallen (zonder decimaal):

"{:,d}".format(1234567)

–

drijvers (met decimaal):

"{:,.2f}".format(1234567)

waar het nummer vóór fhet aantal decimale plaatsen aangeeft.

–

bonus

Snelle en vuile startfunctie voor het Indiase Lakhs / Crores-nummeringssysteem (12.34.567):

https://stackoveroverflow.com/a/44832241/4928578

14

Vanaf Python versie 2.6 kunt u dit doen:

def format_builtin(n):
    return format(n, ',')

Voor Python-versies & LT; 2.6 En alleen voor uw informatie, hier zijn 2 handmatige oplossingen, ze draaien drijvers naar ints, maar negatieve nummers werken correct:

def format_number_using_lists(number):
    string = '%d' % number
    result_list = list(string)
    indexes = range(len(string))
    for index in indexes[::-3][1:]:
        if result_list[index] != '-':
            result_list.insert(index+1, ',')
    return ''.join(result_list)

Weinig dingen om hier te merken:

• Deze regel: String = ‘% D’% nummer Converteert een nummer naar een string, het ondersteunt negatieven en daalt fracties van drijvers, waardoor ze worden weergegeven;
• Deze Slice Indexes [:: – 3] Retourneert elk derde artikel vanaf
  het einde, dus ik heb een andere plak [1:] gebruikt om het allerlaatste item te verwijderen
  want ik heb geen komma nodig na het laatste nummer;
• Deze voorwaardelijke als l [index]! = ‘-‘ – ‘wordt gebruikt om negatieve getallen te ondersteunen, plaats geen komma na het min-teken.

En een meer hardcore versie:

def format_number_using_generators_and_list_comprehensions(number):
    string = '%d' % number
    generator = reversed( 
        [
            value+',' if (index!=0 and value!='-' and index%3==0) else value
            for index,value in enumerate(reversed(string))
        ]
    )
    return ''.join(generator)

Antwoord 15

Hier zijn enkele manieren om dit te doen met opmaak (compatibel met floats en ints)

num = 2437.68
# Way 1: String Formatting
'{:,}'.format(num)
>>> '2,437.68'
# Way 2: F-Strings
f'{num:,}'
>>> '2,437.68'
# Way 3: Built-in Format Function
format(num, ',')
>>> '2,437.68'

Antwoord 16

Ik ben een beginner in Python, maar een ervaren programmeur. Ik heb Python 3.5, dus ik kan gewoon de komma gebruiken, maar dit is niettemin een interessante programmeeroefening. Beschouw het geval van een geheel getal zonder teken. Het meest leesbare Python-programma voor het toevoegen van scheidingstekens voor duizenden lijkt te zijn:

def add_commas(instr):
    out = [instr[0]]
    for i in range(1, len(instr)):
        if (len(instr) - i) % 3 == 0:
            out.append(',')
        out.append(instr[i])
    return ''.join(out)

Het is ook mogelijk om een lijstbegrip te gebruiken:

add_commas(instr):
    rng = reversed(range(1, len(instr) + (len(instr) - 1)//3 + 1))
    out = [',' if j%4 == 0 else instr[-(j - j//4)] for j in rng]
    return ''.join(out)

Dit is korter en kan een voering zijn, maar je zult een paar mentale gymnastiek moeten doen om te begrijpen waarom het werkt. In beide gevallen krijgen we:

for i in range(1, 11):
    instr = '1234567890'[:i]
    print(instr, add_commas(instr))

1 1
12 12
123 123
1234 1,234
12345 12,345
123456 123,456
1234567 1,234,567
12345678 12,345,678
123456789 123,456,789
1234567890 1,234,567,890

De eerste versie is de meer verstandige keuze, als u wilt dat het programma wordt begrepen.

17

Hier is een die ook voor drijvers werkt:

def float2comma(f):
    s = str(abs(f)) # Convert to a string
    decimalposition = s.find(".") # Look for decimal point
    if decimalposition == -1:
        decimalposition = len(s) # If no decimal, then just work from the end
    out = "" 
    for i in range(decimalposition+1, len(s)): # do the decimal
        if not (i-decimalposition-1) % 3 and i-decimalposition-1: out = out+","
        out = out+s[i]      
    if len(out):
        out = "."+out # add the decimal point if necessary
    for i in range(decimalposition-1,-1,-1): # working backwards from decimal point
        if not (decimalposition-i-1) % 3 and decimalposition-i-1: out = ","+out
        out = s[i]+out      
    if f < 0:
        out = "-"+out
    return out

Gebruiksvoorbeeld:

>>> float2comma(10000.1111)
'10,000.111,1'
>>> float2comma(656565.122)
'656,565.122'
>>> float2comma(-656565.122)
'-656,565.122'

Antwoord 18

Eén voering voor Python 2.5+ en Python 3 (alleen positieve int):

''.join(reversed([x + (',' if i and not i % 3 else '') for i, x in enumerate(reversed(str(1234567)))]))

Antwoord 19

Ik gebruik python 2.5, dus ik heb geen toegang tot de ingebouwde opmaak.

Ik keek naar de Django-code intcomma (intcomma_recurs in onderstaande code) en realiseerde me dat het inefficiënt is, omdat het recursief is en ook het compileren van de regex bij elke run is ook geen goede zaak. Dit is niet noodzakelijk een ‘probleem’, aangezien django niet echt ZO gericht is op dit soort prestaties op laag niveau. Ik verwachtte ook een prestatieverschil van factor 10, maar het is slechts 3 keer langzamer.

Uit nieuwsgierigheid heb ik een paar versies van intcomma geïmplementeerd om te zien wat de prestatievoordelen zijn bij het gebruik van regex. Mijn testgegevens concluderen een klein voordeel voor deze taak, maar verrassend genoeg helemaal niet.

Ik was ook blij om te zien wat ik vermoedde: het gebruik van de omgekeerde xrange-aanpak is niet nodig in het geval van no-regex, maar het zorgt er wel voor dat de code er iets beter uitziet ten koste van ~10% prestaties.

Ik neem ook aan dat wat je invoert een tekenreeks is en enigszins op een getal lijkt. Resultaten onbepaald anders.

from __future__ import with_statement
from contextlib import contextmanager
import re,time
re_first_num = re.compile(r"\d")
def intcomma_noregex(value):
    end_offset, start_digit, period = len(value),re_first_num.search(value).start(),value.rfind('.')
    if period == -1:
        period=end_offset
    segments,_from_index,leftover = [],0,(period-start_digit) % 3
    for _index in xrange(start_digit+3 if not leftover else start_digit+leftover,period,3):
        segments.append(value[_from_index:_index])
        _from_index=_index
    if not segments:
        return value
    segments.append(value[_from_index:])
    return ','.join(segments)
def intcomma_noregex_reversed(value):
    end_offset, start_digit, period = len(value),re_first_num.search(value).start(),value.rfind('.')
    if period == -1:
        period=end_offset
    _from_index,segments = end_offset,[]
    for _index in xrange(period-3,start_digit,-3):
        segments.append(value[_index:_from_index])
        _from_index=_index
    if not segments:
        return value
    segments.append(value[:_from_index])
    return ','.join(reversed(segments))
re_3digits = re.compile(r'(?<=\d)\d{3}(?!\d)')
def intcomma(value):
    segments,last_endoffset=[],len(value)
    while last_endoffset > 3:
        digit_group = re_3digits.search(value,0,last_endoffset)
        if not digit_group:
            break
        segments.append(value[digit_group.start():last_endoffset])
        last_endoffset=digit_group.start()
    if not segments:
        return value
    if last_endoffset:
        segments.append(value[:last_endoffset])
    return ','.join(reversed(segments))
def intcomma_recurs(value):
    """
    Converts an integer to a string containing commas every three digits.
    For example, 3000 becomes '3,000' and 45000 becomes '45,000'.
    """
    new = re.sub("^(-?\d+)(\d{3})", '\g<1>,\g<2>', str(value))
    if value == new:
        return new
    else:
        return intcomma(new)
@contextmanager
def timed(save_time_func):
    begin=time.time()
    try:
        yield
    finally:
        save_time_func(time.time()-begin)
def testset_xsimple(func):
    func('5')
def testset_simple(func):
    func('567')
def testset_onecomma(func):
    func('567890')
def testset_complex(func):
    func('-1234567.024')
def testset_average(func):
    func('-1234567.024')
    func('567')
    func('5674')
if __name__ == '__main__':
    print 'Test results:'
    for test_data in ('5','567','1234','1234.56','-253892.045'):
        for func in (intcomma,intcomma_noregex,intcomma_noregex_reversed,intcomma_recurs):
            print func.__name__,test_data,func(test_data)
    times=[]
    def overhead(x):
        pass
    for test_run in xrange(1,4):
        for func in (intcomma,intcomma_noregex,intcomma_noregex_reversed,intcomma_recurs,overhead):
            for testset in (testset_xsimple,testset_simple,testset_onecomma,testset_complex,testset_average):
                for x in xrange(1000): # prime the test
                    testset(func)
                with timed(lambda x:times.append(((test_run,func,testset),x))):
                    for x in xrange(50000):
                        testset(func)
    for (test_run,func,testset),_delta in times:
        print test_run,func.__name__,testset.__name__,_delta

En hier zijn de testresultaten:

intcomma 5 5
intcomma_noregex 5 5
intcomma_noregex_reversed 5 5
intcomma_recurs 5 5
intcomma 567 567
intcomma_noregex 567 567
intcomma_noregex_reversed 567 567
intcomma_recurs 567 567
intcomma 1234 1,234
intcomma_noregex 1234 1,234
intcomma_noregex_reversed 1234 1,234
intcomma_recurs 1234 1,234
intcomma 1234.56 1,234.56
intcomma_noregex 1234.56 1,234.56
intcomma_noregex_reversed 1234.56 1,234.56
intcomma_recurs 1234.56 1,234.56
intcomma -253892.045 -253,892.045
intcomma_noregex -253892.045 -253,892.045
intcomma_noregex_reversed -253892.045 -253,892.045
intcomma_recurs -253892.045 -253,892.045
1 intcomma testset_xsimple 0.0410001277924
1 intcomma testset_simple 0.0369999408722
1 intcomma testset_onecomma 0.213000059128
1 intcomma testset_complex 0.296000003815
1 intcomma testset_average 0.503000020981
1 intcomma_noregex testset_xsimple 0.134000062943
1 intcomma_noregex testset_simple 0.134999990463
1 intcomma_noregex testset_onecomma 0.190999984741
1 intcomma_noregex testset_complex 0.209000110626
1 intcomma_noregex testset_average 0.513000011444
1 intcomma_noregex_reversed testset_xsimple 0.124000072479
1 intcomma_noregex_reversed testset_simple 0.12700009346
1 intcomma_noregex_reversed testset_onecomma 0.230000019073
1 intcomma_noregex_reversed testset_complex 0.236999988556
1 intcomma_noregex_reversed testset_average 0.56299996376
1 intcomma_recurs testset_xsimple 0.348000049591
1 intcomma_recurs testset_simple 0.34600019455
1 intcomma_recurs testset_onecomma 0.625
1 intcomma_recurs testset_complex 0.773999929428
1 intcomma_recurs testset_average 1.6890001297
1 overhead testset_xsimple 0.0179998874664
1 overhead testset_simple 0.0190000534058
1 overhead testset_onecomma 0.0190000534058
1 overhead testset_complex 0.0190000534058
1 overhead testset_average 0.0309998989105
2 intcomma testset_xsimple 0.0360000133514
2 intcomma testset_simple 0.0369999408722
2 intcomma testset_onecomma 0.207999944687
2 intcomma testset_complex 0.302000045776
2 intcomma testset_average 0.523000001907
2 intcomma_noregex testset_xsimple 0.139999866486
2 intcomma_noregex testset_simple 0.141000032425
2 intcomma_noregex testset_onecomma 0.203999996185
2 intcomma_noregex testset_complex 0.200999975204
2 intcomma_noregex testset_average 0.523000001907
2 intcomma_noregex_reversed testset_xsimple 0.130000114441
2 intcomma_noregex_reversed testset_simple 0.129999876022
2 intcomma_noregex_reversed testset_onecomma 0.236000061035
2 intcomma_noregex_reversed testset_complex 0.241999864578
2 intcomma_noregex_reversed testset_average 0.582999944687
2 intcomma_recurs testset_xsimple 0.351000070572
2 intcomma_recurs testset_simple 0.352999925613
2 intcomma_recurs testset_onecomma 0.648999929428
2 intcomma_recurs testset_complex 0.808000087738
2 intcomma_recurs testset_average 1.81900000572
2 overhead testset_xsimple 0.0189998149872
2 overhead testset_simple 0.0189998149872
2 overhead testset_onecomma 0.0190000534058
2 overhead testset_complex 0.0179998874664
2 overhead testset_average 0.0299999713898
3 intcomma testset_xsimple 0.0360000133514
3 intcomma testset_simple 0.0360000133514
3 intcomma testset_onecomma 0.210000038147
3 intcomma testset_complex 0.305999994278
3 intcomma testset_average 0.493000030518
3 intcomma_noregex testset_xsimple 0.131999969482
3 intcomma_noregex testset_simple 0.136000156403
3 intcomma_noregex testset_onecomma 0.192999839783
3 intcomma_noregex testset_complex 0.202000141144
3 intcomma_noregex testset_average 0.509999990463
3 intcomma_noregex_reversed testset_xsimple 0.125999927521
3 intcomma_noregex_reversed testset_simple 0.126999855042
3 intcomma_noregex_reversed testset_onecomma 0.235999822617
3 intcomma_noregex_reversed testset_complex 0.243000030518
3 intcomma_noregex_reversed testset_average 0.56200003624
3 intcomma_recurs testset_xsimple 0.337000131607
3 intcomma_recurs testset_simple 0.342000007629
3 intcomma_recurs testset_onecomma 0.609999895096
3 intcomma_recurs testset_complex 0.75
3 intcomma_recurs testset_average 1.68300008774
3 overhead testset_xsimple 0.0189998149872
3 overhead testset_simple 0.018000125885
3 overhead testset_onecomma 0.018000125885
3 overhead testset_complex 0.0179998874664
3 overhead testset_average 0.0299999713898

Antwoord 20

Dit levert geld op samen met de komma’s

def format_money(money, presym='$', postsym=''):
    fmt = '%0.2f' % money
    dot = string.find(fmt, '.')
    ret = []
    if money < 0 :
        ret.append('(')
        p0 = 1
    else :
        p0 = 0
    ret.append(presym)
    p1 = (dot-p0) % 3 + p0
    while True :
        ret.append(fmt[p0:p1])
        if p1 == dot : break
        ret.append(',')
        p0 = p1
        p1 += 3
    ret.append(fmt[dot:])   # decimals
    ret.append(postsym)
    if money < 0 : ret.append(')')
    return ''.join(ret)

Antwoord 21

Ik heb een python 2- en python 3-versie van deze code. Ik weet dat de vraag werd gesteld voor python 2, maar nu (8 jaar later lol) zullen mensen waarschijnlijk python 3 gebruiken.

Python 3-code:

import random
number = str(random.randint(1, 10000000))
comma_placement = 4
print('The original number is: {}. '.format(number))
while True:
    if len(number) % 3 == 0:
        for i in range(0, len(number) // 3 - 1):
            number = number[0:len(number) - comma_placement + 1] + ',' + number[len(number) - comma_placement + 1:]
            comma_placement = comma_placement + 4
    else:
        for i in range(0, len(number) // 3):
            number = number[0:len(number) - comma_placement + 1] + ',' + number[len(number) - comma_placement + 1:]
    break
print('The new and improved number is: {}'.format(number))        

Python 2-code: (bewerken. De python 2-code werkt niet. Ik denk dat de syntaxis anders is).

import random
number = str(random.randint(1, 10000000))
comma_placement = 4
print 'The original number is: %s.' % (number)
while True:
    if len(number) % 3 == 0:
        for i in range(0, len(number) // 3 - 1):
            number = number[0:len(number) - comma_placement + 1] + ',' + number[len(number) - comma_placement + 1:]
            comma_placement = comma_placement + 4
    else:
        for i in range(0, len(number) // 3):
            number = number[0:len(number) - comma_placement + 1] + ',' + number[len(number) - comma_placement + 1:]
    break
print 'The new and improved number is: %s.' % (number) 

Antwoord 22

dit wordt in python gebakken per PEP -> https://www.python.org/dev/peps/pep-0378/

gebruik gewoon format(1000, ‘,d’) om een geheel getal weer te geven met het scheidingsteken voor duizendtallen

er zijn meer formaten beschreven in de PEP, let op

Antwoord 23

Gebruik scheidingstekens en decimalen samen in zwevende getallen:
(In dit voorbeeld twee decimalen)

large_number = 4545454.26262666
print(f"Formatted: {large_number:,.2f}")

Resultaat:
Geformatteerd: 4.545.454.26

Antwoord 24

Hier is nog een variant die een generatorfunctie gebruikt die werkt voor gehele getallen:

def ncomma(num):
    def _helper(num):
        # assert isinstance(numstr, basestring)
        numstr = '%d' % num
        for ii, digit in enumerate(reversed(numstr)):
            if ii and ii % 3 == 0 and digit.isdigit():
                yield ','
            yield digit
    return ''.join(reversed([n for n in _helper(num)]))

En hier is een test:

>>> for i in (0, 99, 999, 9999, 999999, 1000000, -1, -111, -1111, -111111, -1000000):
...     print i, ncomma(i)
... 
0 0
99 99
999 999
9999 9,999
999999 999,999
1000000 1,000,000
-1 -1
-111 -111
-1111 -1,111
-111111 -111,111
-1000000 -1,000,000

Antwoord 25

Gewoon subklasse long(of float, of wat dan ook). Dit is erg praktisch, omdat je op deze manier je cijfers nog steeds kunt gebruiken in wiskunde (en dus bestaande code), maar ze zullen allemaal mooi worden afgedrukt in je terminal.

>>> class number(long):
        def __init__(self, value):
            self = value
        def __repr__(self):
            s = str(self)
            l = [x for x in s if x in '1234567890']
            for x in reversed(range(len(s)-1)[::3]):
                l.insert(-x, ',')
            l = ''.join(l[1:])
            return ('-'+l if self < 0 else l) 
>>> number(-100000)
-100,000
>>> number(-100)
-100
>>> number(-12345)
-12,345
>>> number(928374)
928,374
>>> 345

Antwoord 26

Italië:

>>> import locale
>>> locale.setlocale(locale.LC_ALL,"")
'Italian_Italy.1252'
>>> f"{1000:n}"
'1.000'

Antwoord 27

babel-module in python heeft een functie om komma’s toe te passen, afhankelijk van de opgegeven landinstelling.

Voer de onderstaande opdracht uit om babel te installeren.

pip install babel

gebruik

format_currency(1234567.89, 'USD', locale='en_US')
# Output: $1,234,567.89
format_currency(1234567.89, 'USD', locale='es_CO')
# Output: US$ 1.234.567,89 (raw output US$\xa01.234.567,89)
format_currency(1234567.89, 'INR', locale='en_IN')
# Output: ₹12,34,567.89

Antwoord 28

Voor drijvers:

float(filter(lambda x: x!=',', '1,234.52'))
# returns 1234.52

Voor informatie:

int(filter(lambda x: x!=',', '1,234'))
# returns 1234