我正在尝试使用逗号作为千位分隔符在 Python 2.6.1 中打印整数。例如，我想将1234567显示为1,234,567。我该怎么做呢？我在Google上看过很多例子，但我正在寻找最简单实用的方法。
不需要特定于语言环境来决定句点和逗号。我更喜欢尽可能简单的事情。
答案 0 :(得分：1508)
对于Python≥2.7：
"{:,}".format(value)
每Format Specification Mini-Language，
','选项表示使用逗号表示千位分隔符。对于区域设置感知分隔符，请改用'n'整数表示形式。
答案 1 :(得分：272)
我让这个工作：
>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'en_US')
'en_US'
>>> locale.format("%d", 1255000, grouping=True)
'1,255,000'
当然，您不需要需要国际化支持，但它清晰，简洁，并且使用内置库。
P.S。 “％d”是通常的％风格格式化程序。您只能拥有一个格式化程序，但它可以是您在字段宽度和精度设置方面所需的任何内容。
P.P.S。如果你无法让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)
递归对于负面情况很有用，但每个逗号的一次递归对我来说似乎有些过分。
答案 2 :(得分：108)
由于效率低下和不可读性，很难被击败：
>>> 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('-,','-')
答案 3 :(得分：91)
以下是删除不相关部分并稍微清理后的区域设置分组代码：
（以下仅适用于整数）
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中，将有一个千位分隔符的格式说明符。根据{{3}}，它的工作原理如下
>>> '{:20,.2f}'.format(f)
'18,446,744,073,709,551,616.00'
在python3.1中你可以做同样的事情：
>>> format(1234567, ',d')
'1,234,567'
答案 4 :(得分：49)
我很惊讶没有人提到你可以用Python 3.6中的f字符串做到这一点就像这样简单：
>>> num = 10000000
>>> print(f"{num:,d}")
10,000,000
...冒号后面的部分是格式说明符。逗号是您想要的分隔符，因此f"{num:_d}"使用下划线而不是逗号。
这相当于对旧版本的python 3使用format(num, ",d")。
答案 5 :(得分：35)
这是一个单行正则表达式替换：
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'
NB：因为它会尝试对小数部分进行分组，所以不能正常使用三位以上的数字：
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
答案 6 :(得分：24)
这就是我为花车做的事情。虽然，老实说，我不确定它适用于哪个版本 - 我使用的是2.7：
my_number = 4385893.382939491
my_string = '{:0,.2f}'.format(my_number)
返回：4,385,893.38
更新：我最近遇到了这种格式的问题（无法告诉您具体原因），但是可以通过删除0
my_string = '{:,.2f}'.format(my_number)
答案 7 :(得分：18)
您还可以使用'{: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'
答案 8 :(得分：11)
我确信必须有一个标准的库函数，但尝试使用递归自己编写它很有趣所以这就是我想出的：
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)
话虽如此，如果其他人确实找到了标准的方法，那么你应该使用它。
答案 9 :(得分：8)
从comments到有效状态的食谱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，即(?=\d)，以确保只有三位数字的组在其后有一个数字后才能得到逗号。我说'之后'因为此时字符串是反向的。
[::-1]只是反转一个字符串。
答案 10 :(得分：8)
稍微扩大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
答案 11 :(得分：6)
-
整数（不含小数）：
"{:,d}".format(1234567)
-
浮动（带小数）：
"{:,.2f}".format(1234567)
其中f之前的数字指定小数位数。
-
<强>加成
印度劳克斯/ crores编号系统的快速启动功能（12,34,567）：
答案 12 :(得分：5)
接受的答案很好，但实际上我更喜欢format(number,',')。我更容易理解和记忆。
答案 13 :(得分：4)
def format_builtin(n):
return format(n, ',')
对于Python版本＆lt; 2.6并且只是为了您的信息，这里有2个手动解决方案，它们将浮点数转换为整数但负数字正常工作：
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)
这里有几点需要注意：
更硬核版本：
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)
答案 14 :(得分：2)
这里有一些格式化的方法（与浮点数和整数兼容）
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'
答案 15 :(得分：1)
在上一个投票最高的答案中，我发现了点分隔符的一些问题。我设计了一种通用解决方案，您可以在不修改语言环境的情况下将任何内容用作千位分隔符。我知道这不是最优雅的解决方案，但可以完成工作。随时进行改进！
def format_integer(number, thousand_separator='.'):
def reverse(string):
string = "".join(reversed(string))
return string
s = reverse(str(number))
count = 0
result = ''
for char in s:
count = count + 1
if count % 3 == 0:
if len(s) == count:
result = char + result
else:
result = thousand_separator + char + result
else:
result = char + result
return result
print(format_integer(50))
# 50
print(format_integer(500))
# 500
print(format_integer(50000))
# 50.000
print(format_integer(50000000))
# 50.000.000
答案 16 :(得分：1)
这里也适用于花车：
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'
答案 17 :(得分：1)
我是一名Python初学者，但是一位经验丰富的程序员。我有Python 3.5，所以我可以使用逗号，但这仍然是一个有趣的编程练习。考虑无符号整数的情况。用于添加数千个分隔符的最易读的Python程序似乎是：
private static int[] GetArrayIndexList<T>(IList<T> arrMain, T[] arrFiltered) where T : struct
{
return arrFiltered.Select(c=> arrMain.IndexOf(c)).ToArray();
}
也可以使用列表理解：
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))
如果您希望理解该程序，第一个版本是更明智的选择。
答案 18 :(得分：1)
Python 2.5+和Python 3的一个衬垫（仅限正int）：
''.join(reversed([x + (',' if i and not i % 3 else '') for i, x in enumerate(reversed(str(1234567)))]))
答案 19 :(得分：0)
这可以带钱和逗号
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)
答案 20 :(得分：0)
python 中的 babel 模块具有根据提供的语言环境应用逗号的功能。
要安装 babel，请运行以下命令。
pip install babel
使用
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
答案 21 :(得分：0)
我有一个python 2和python 3版本的代码。我知道问题是python 2，但是现在（8年后lol）人们可能会使用python 3.
Python 3代码：
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代码:(编辑.python 2代码不工作。我认为语法不同）。
URL答案 22 :(得分：0)
我正在使用python 2.5，因此我无法访问内置格式。
我查看了Django代码intcomma（下面代码中的intcomma_recurs）并意识到它效率低下，因为它是递归的，并且在每次运行时编译正则表达式也不是一件好事。这不是一个“问题”，因为django并不是真的专注于这种低级别的表现。此外，我期待性能差异为10倍，但速度只有3倍。
出于好奇，我实现了几个版本的intcomma，以了解使用正则表达式时的性能优势。我的测试数据总结了这项任务的一个小优势，但令人惊讶的是没有多少。
我也很高兴看到我所怀疑的：在非正则表达式的情况下使用反向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
答案 23 :(得分：0)
我这样解决了......对于一个dictonary
from random import randint
voci = {
"immobilizzazioni": randint(200000, 500000),
"tfr": randint(10000, 25000),
"ac": randint(150000, 200000),
"fondo": randint(10500, 22350),
"debiti": randint(150000, 250000),
"ratei_attivi": randint(2000, 2500),
"ratei_passivi": randint(1500, 2600),
"crediti_v_soci": randint(10000, 30000)
}
testo_rnd2 = """Nell’azienda Hypermax S.p.a. di Bologna le immobilizzazioni valgono {immobilizzazioni:,} €, i debiti per TFR sono pari a {tfr:,} €, l’attivo circolante è di {ac:,} euro, il fondo rischi ed oneri ha un importo pari a {fondo:,} euro, i debiti sono {debiti:,} €, i ratei e risconti attivi sono pari a {ratei_attivi:,} euro, i ratei e risconti passivi sono pari a {ratei_passivi:,} euro. I crediti verso i soci sono pari a {crediti_v_soci:,} euro."""
print(testo_rnd2)
出： le immobilizzazioni valgono 419.168€。我debiti每TFR sono pari 13.255€。 l'attivocircolanteèdi195.443欧元。 il fondo rischi ed oneri ha un importo pari 13.374欧元。我debiti sono 180.947€。我评价一个2.271欧元的收益率。我评价一个1.864欧元的risconti passivi sono pari。我相信我的社会声音为17.630欧元。
答案 24 :(得分：-1)
只是子类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
答案 25 :(得分：-1)
这是使用适用于整数的生成器函数的另一个变体：
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
答案 26 :(得分：-1)
根据PEP将其烘焙到python中-> https://www.python.org/dev/peps/pep-0378/
只需使用format（1000，'，d'）来显示带有千位分隔符的整数
PEP中描述了更多格式，
答案 27 :(得分：-3)
我更喜欢基于语言环境的实际项目解决方案，但我认为应该在这里提到使用切片分配的方法：
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
答案 28 :(得分：-8)
对于花车：
float(filter(lambda x: x!=',', '1,234.52'))
# returns 1234.52
对于整数：
int(filter(lambda x: x!=',', '1,234'))
# returns 1234
答案 29 :(得分：-9)
如果您不想依赖任何外部库：
s = str(1234567)
print ','.join([s[::-1][k:k+3][::-1] for k in xrange(len(s)-1, -1, -3)])
这仅适用于非负整数。