如何使用逗号作为千位分隔符来打印数字？
我想用逗号作为千位分隔符在Python 2.6.1中打印一个整数。 例如，我想显示数字1234567为1,234,567 。 我怎么去做这个？ 我在Google上看过很多例子，但我正在寻找最简单的实用方法。
它不需要特定于语言环境来决定句点和逗号。 我宁愿一些尽可能简单的事情。
对于Python≥2.7：
"{:,}".format(value)
按格式规范迷你语言 ，
','选项表示使用千位分隔符的逗号。 对于区域识别分隔符，请使用'n'整数表示类型。
我得到这个工作：
>>> import locale >>> locale.setlocale(locale.LC_ALL, 'en_US') 'en_US' >>> locale.format("%d", 1255000, grouping=True) '1,255,000'
当然，你不需要国际化的支持，但它很清楚，简洁，并使用一个内置的库。
PS“％d”是通常的％风格的格式化程序。 你只能有一个格式化器，但是它可以是任何你需要的字段宽度和精度设置。
PPS如果你不能让locale工作，我会建议马克的答案修改后的版本：
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)
递归对于负面情况是有用的，但是每个逗号递归似乎对我来说有点过分。
删除不相关的部分并清理一下后，这里是语言环境分组代码：
（以下仅适用于整数）
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'
这里已经有一些很好的答案了。 我只是想添加这个以备将来参考。 在Python 2.7中将会有一个千位分隔符的格式说明符。 根据python文档，它的作品是这样的
>>> '{:20,.2f}'.format(f) '18,446,744,073,709,551,616.00'
在python3.1中，你可以像这样做同样的事情：
>>> format(1234567, ',d') '1,234,567'
为了低效率和不可读性，这很难被打败：
>>> 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('-,','-')
这是一个单行的正则表达式替换：
re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%d" % val)
仅适用于不合格产品：
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'
或者对于少于4位的浮点数，将格式说明符更改为%.3f ：
re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%.3f" % val) # Returns: '1,234,567,890.123'
注意：不能正确地使用三位以上的十进制数字，因为它会尝试对小数部分进行分组：
re.sub("(\d)(?=(\d{3})+(?!\d))", r"\1,", "%.5f" % val) # Returns: '1,234,567,890.12,346'
怎么运行的
让我们来分解一下：
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
您也可以使用'{:n}'.format( value )为区域设置表示'{:n}'.format( value ) 。 我认为这是一个现场解决方案的最简单的方法。
有关更多信息，请在Python DOC中搜索thousands 。
对于货币，您可以使用locale.currency ，设置标志grouping ：
码
import locale locale.setlocale( locale.LC_ALL, '' ) locale.currency( 1234567.89, grouping = True )
产量
'Portuguese_Brazil.1252' 'R$ 1.234.567,89'
这是我为花车做的。 虽然，老实说，我不确定它适用于哪个版本 – 我使用2.7：
my_number = 4385893.382939491 my_string = '{:0,.2f}'.format(my_number)
返回：4,385,893.38
更新：我最近有一个问题，这种格式（不能告诉你确切的原因），但能够解决它通过删除0 ：
my_string = '{:,.2f}'.format(my_number)
我确定必须有一个标准的库函数，但是使用递归来自己写这个函数是很有趣的，所以下面是我想到的：
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)
话虽如此，如果别人找到了一个标准的方法来做到这一点，你应该使用它。
从评论到activestate食谱498181我重做了这个：
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
它使用正则表达式功能： lookahead ie (?=\d)确保只有三位数字的数字在“之后”得到一个逗号。 我之后说'之后'，因为字符串在这一点上是相反的。
[::-1]只是反转一个字符串。
我很惊讶没有人提到你可以用Python 3.6中的f-strings做到这一点：
>>> num = 10000000 >>> print(f"{num:,d}") 10,000,000
…冒号后面的部分是格式说明符。 逗号是你想要的分隔符，所以f"{num:_d}"使用下划线而不是逗号。
这相当于使用老版本的python 3的format(num, ",d") 。
从Python版本2.6你可以做到这一点：
def format_builtin(n): return format(n, ',')
对于Python版本<2.6，仅供参考，以下是两个手动解决方案，它们将浮点数转换为整数，但负数正确工作：
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)
这里有几件事要注意：
- 这一行： string ='％d'％数字将数字转换为一个字符串，它支持负数，并从浮点数中删除分数，使它们整数;
- 这个索引[： – 3]返回从结尾开始的每个第三个项目，所以我用另一个切片[1：]来删除最后一个项目因为最后一个数字后我不需要逗号;
- 这个条件如果l [index]！=' – '被用来支持负数，不要在减号后插入一个逗号。
而更核心的版本：
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)
这也是一个适用于花车的人：
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
用法示例：
>>> float2comma(10000.1111) '10,000.111,1' >>> float2comma(656565.122) '656,565.122' >>> float2comma(-656565.122) '-656,565.122'
Python 2.5+和Python 3的一个班轮（仅限正整数）：
''.join(reversed([x + (',' if i and not i % 3 else '') for i, x in enumerate(reversed(str(1234567)))]))
我是一个Python初学者，但是一个有经验的程序员。 我有Python 3.5，所以我可以使用逗号，但这是一个有趣的编程练习。 考虑无符号整数的情况。 用于添加数千个分隔符的最易读的Python程序似乎是：
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)
也可以使用列表理解：
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)
这个比较短，可能是一个班轮，但你必须做一些心理体操来理解它为什么起作用。 在这两种情况下我们得到：
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
第一个版本是更明智的选择，如果你想要了解程序。
Python 3
–
整数（不含小数）：
"{:,d}".format(1234567)
–
浮动（十进制）：
"{:,.2f}".format(1234567)
f之前的数字指定小数位数。
–
奖金
印度十万个/千分制编号系统（12,34,567）的快速启动功能：
这与逗号一起赚钱
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)
我有这个代码的python 2和python 3版本。 我知道这个问题是要求python 2，但现在（8年后，大声笑）人们可能会使用python 3。
Python 3代码：
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代码:(编辑。python 2代码不工作，我认为语法是不同的）。
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)
我正在使用Python 2.5，所以我没有访问内置的格式。
我查看了Django代码intcomma（在下面的代码中是intcomma_recurs），并意识到它是低效的，因为它是递归的，并且在每次运行时编译正则表达式也不是好事。 这不是一个'问题'，因为django并不是真正关注这种低级表现。 另外，我预计性能会有10倍的差距，但速度只有3倍。
出于好奇，我实现了几个版本的intcomma，看看使用正则表达式的性能优势。 我的测试数据总结了这项任务的轻微优势，但令人惊讶的是没有多少。
我也很高兴看到我怀疑的是：在no-regex的情况下使用反向xrange方法是不必要的，但是它确实使得代码看起来稍微好一点，代价是〜10％的性能。
另外，我假定你传递的是一个字符串，看起来有点像一个数字。 否则结果不确定。
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
这里是测试结果：
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
只是子类long （或float ，或其他）。 这是非常实用的，因为这样你仍然可以在数学运算中使用你的数字（因此也就是现有的代码），但是它们都将在你的终端中很好地打印出来。
>>> 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
伊恩•施耐德（Ian Schneider）的答案略有扩展：
如果您想使用自定义千位分隔符，最简单的解决方案是：
'{:,}'.format(value).replace(',', your_custom_thousands_separator)
例子
'{:,.2f}'.format(123456789.012345).replace(',', ' ')
如果你想像这样的德国代表，它会更复杂一点：
('{:,.2f}'.format(123456789.012345) .replace(',', ' ') # 'save' the thousands separators .replace('.', ',') # dot to comma .replace(' ', '.')) # thousand separators to dot
接受的答案是好的，但我更喜欢format(number,',') 。 我更容易解读和记忆。
这里是另一个使用生成器函数的变体：
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)]))
这是一个测试：
>>> 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
我更喜欢真正项目的基于区域的解决方案，但这里是一个简单而有效的选择：
def format_money(f, delimiter=',', frac_digits=2): negative_fix = int(f < 0) s = '%.*f' % (frac_digits, f) if len(s) < 5 + frac_digits + negative_fix: return s l = list(s) l_fix = l[negative_fix:] p = len(l_fix) - frac_digits - 5 l_fix[p::-3] = [i + delimiter for i in l_fix[p::-3]] return ''.join(l[:negative_fix] + l_fix)
主要与doctests那里 – https://gist.github.com/ei-grad/b290dc761ae253af69438bbb94d82683
对于花车：
float(filter(lambda x: x!=',', '1,234.52')) # returns 1234.52
对于整数：
int(filter(lambda x: x!=',', '1,234')) # returns 1234
如果你不想依赖任何外部库：
s = str(1234567) print ','.join([s[::-1][k:k+3][::-1] for k in xrange(len(s)-1, -1, -3)])
这只适用于非负整数。
