كيفية طباعة عدد بفواصل كما فواصل الآلاف?

StackOverflow https://stackoverflow.com/questions/1823058

  •  10-07-2019
  •  | 
  •  

سؤال

أنا أحاول طباعة عدد صحيح في بيثون 2.6.1 مع الفواصل كما فواصل الآلاف.على سبيل المثال أريد أن تظهر عدد 1234567 كما 1,234,567.كيف لي أن أفعل هذا ؟ لقد رأيت العديد من الأمثلة على جوجل, ولكن أنا أبحث عن أبسط طريقة عملية.

أنها لا تحتاج إلى أن تكون لغة معينة أن تقرر بين فترات الفواصل.أنا أفضل شيء بسيط ممكن في حدود المعقول.

هل كانت مفيدة؟

المحلول

لغة علم 

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

لغة علم 

import locale
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')  # Customize

'{:n}'.format(value)  # For Python ≥2.7
f'{value:n}'  # For Python ≥3.7

المرجع

تنسيق مواصفات ميني اللغة و

<اقتباس فقرة>   

والخيار ',' يشير إلى استخدام فاصلة لآلاف فاصل. للغة فاصل علم، استخدام العرض التقديمي صحيح 'n' اكتب بدلا من ذلك.

نصائح أخرى

وحصلت على هذا العمل: 

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

وبالتأكيد، كنت لا <م> الحاجة الدعم الدولي، ولكن من الواضح وموجزة، ويستخدم المدمج في المكتبة.

وP.S. أن "٪ د" هو المعتاد٪ المنسق على غرار. هل يمكن أن يكون المنسق واحد فقط، ولكن يمكن أن يكون كل ما تحتاجه من حيث العرض والدقة إعدادات المجال.

و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)

والعودية غير مفيدة لحالة سلبية، ولكن العودية واحد لكل فاصلة يبدو قليلا المفرط بالنسبة لي.

لعدم الكفاءة وunreadability أنه من الصعب الفوز على: 

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

وهنا هو لغة تجميع التعليمات البرمجية بعد إزالة أجزاء غير ذي صلة وتنظيفه قليلا:

(وفيما يلي يعمل فقط من أجل الأعداد الصحيحة) 

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'

وهناك بالفعل بعض الإجابات جيدة هنا. أريد فقط أن إضافة هذا للرجوع إليها في المستقبل. في بيثون 2.7 هناك ستكون محدد التنسيق لآلاف فاصل. ووفقا ل الثعبان مستندات يعمل مثل هذا 

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

في python3.1 يمكنك أن تفعل نفس الشيء مثل هذا: 

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

وأنا مندهش أن أحدا قد ذكر أنه يمكنك القيام بذلك مع سلاسل و في بيثون 3.6 سهلا كما يلي: 

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

... حيث الجزء بعد النقطتين هو شكل محدد. الفاصلة هي الحرف الفاصل الذي تريده، حتى f"{num:_d}" يستخدم يؤكد بدلا من فاصلة.

وهذا يعادل استخدام format(num, ",d") للإصدارات القديمة من الثعبان 3.

هنا سطر واحد regex الاستبدال:

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

يعمل فقط من أجل inegral النواتج:

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

وهذا هو ما أقوم به ليطفو. وعلى الرغم من بصراحة، أنا لست متأكدا من الإصدارات كان يعمل ل- أنا باستخدام 2.7: 

my_number = 4385893.382939491

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

وإرجاع: 4،385،893.38

تحديث: وقد أتيحت لي مؤخرا مشكلة مع هذا الشكل (لا يمكن أن أقول لك السبب الدقيق)، ولكن كانت قادرة على اصلاحها من خلال إسقاط 0: 

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

يمكنك أيضا استخدام '{:n}'.format( value ) عن لغة التمثيل.أعتقد أن هذا هو simpliest طريقة لغة الحل.

للحصول على مزيد من المعلومات بحث عن thousands في بيثون DOC.

على العملة ، يمكنك استخدام locale.currency, ووضع العلم grouping:

رمز

import locale

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

الإخراج

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

وأنا متأكد من يجب أن يكون هناك وظيفة المكتبة القياسية لهذا، ولكنه كان متعة في محاولة لكتابة بنفسي باستخدام العودية حتى هنا هو ما خطرت لي: 

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)

وأما وقد قلت ذلك، إذا كان شخص آخر لا يجد وسيلة معيارية للقيام بذلك، يجب عليك استخدام بدلا من ذلك.

href="http://code.activestate.com/recipes/498181-add-thousands-separator-commas-to-formatted-number/#c3" لصفة 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 أي (?=\d) لجعل تأكد الجماعات الوحيدة من ثلاثة أرقام التي لديها أرقام 'بعد' لهم الحصول على فاصلة. أقول 'بعد' لأن السلسلة عكس عند هذه النقطة.

و[::-1] فقط عكس سلسلة.

وقليلا توسيع إجابة لإيان شنايدر:

إذا كنت ترغب في استخدام الآلاف مخصصة الفاصل، وأبسط الحلول هو: 

'{:,}'.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

بيثون 3

--

الأعداد الصحيحة (بدون عشري):

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

--

العوامات (مع عشري):

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

حيث بلغ عدد قبل f يحدد عدد من المنازل العشرية.

--

مكافأة

سريعة وقذرة كاتب وظيفة الهندي لاكس/كرور نظام الترقيم (12,34,567):

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

والجواب المقبول على ما يرام، ولكن أنا فعلا تفضل format(number,','). أسهل بالنسبة لي لتفسير والتذكر.

https://docs.python.org/3/library/functions. أتش تي أم أل # شكل

من بيثون الإصدار 2.6 يمكنك القيام بذلك:

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

للحصول على إصدارات بيثون < 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)

عدد قليل من الأشياء أن نلاحظ هنا:

  • هذا السطر: string = '%d % عدد جميل تحويل الرقم إلى سلسلة ، وهو يدعم السلبيات و قطرات الكسور من العوامات ، مما يجعلها رجات;
  • هذه شريحة الفهارس[::-3] يعود بعضها البند الثالث بدءا من اذا كنت تستخدم شريحة أخرى [1:] لإزالة آخر البند كوز لا تحتاج فاصلة بعد آخر ؛
  • هذا الشرطي إذا كان l[فهرس] != '-' يتم دعم الأرقام السلبية ، لا تقم بإدخال فاصلة بعد الطرح.

و أكثر المتشددين الإصدار:

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'

وبطانة واحدة لبيثون 2.5+ وبيثون 3 (دولي إيجابي فقط): 

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

وأنا مبتدئ بيثون، ولكن مبرمج من ذوي الخبرة. لدي بيثون 3.5، حتى أستطيع أن مجرد استخدام الفاصلة، ولكن هذا على الرغم من ذلك ممارسة البرمجة مثيرة للاهتمام. النظر في القضية من عدد صحيح غير موقعة. يظهر البرنامج بيثون الأكثر قراءة لإضافة الآلاف فواصل لتكون: 

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

والنسخة الأولى هو الخيار الأكثر عقلانية، إذا كنت تريد البرنامج ليكون مفهوما.

وتخبز هذا إلى الثعبان في PEP -> الشبكي: //www.python كافيه / ديف / ممثلي المخاطر / الحماسي-0378 /

ومجرد استخدام صيغة (1000، '،' د) لإظهار عدد صحيح مع الآلاف فاصل

وهناك المزيد من الأشكال وصفها في PEP، ويكون في ذلك

وهذا لا المال إلى جانب الفواصل 

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)

ولدي نسخة الثعبان 2 و الثعبان 3 من هذا القانون. وأنا أعلم أن مسألة سئل عن الثعبان 2 ولكن الآن (بعد 8 سنوات لول) الناس من المحتمل أن يستخدم بيثون 3.

بيثون 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))

و
الثعبان 2 رمز: (تعديل كود الثعبان 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)

وأنا باستخدام بيثون 2.5 لذلك أنا لا يستطيعون الوصول إلى المدمج في التنسيق.

ونظرت إلى intcomma كود جانغو (intcomma_recurs في التعليمات البرمجية أدناه)، وأدركت أنها غير فعالة، لأنها متكررة، وكذلك تجميع التعبير المعتاد في كل شوط ليست أمرا جيدا أيضا. هذا ليس ضروريا ل'قضية' كما جانغو ليست في الحقيقة مركزة على هذا النوع من الأداء على مستوى منخفض. أيضا، كنت أتوقع عامل من 10 فرق في الأداء، ولكن هذا فقط 3 مرات أبطأ.

وبدافع الفضول I نفذت عدة إصدارات 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

تحليل أرقام الإيطالية: '' ألف الفاصل هو

وأنا حلها بهذه الطريقة ... ل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)

والخروج: لو immobilizzazioni valgono 419،168 €. ط debiti في معدل الخصوبة الإجمالي سونو باري من 13،255 €. L'فوتوغرافية Attivo circolante è دي 195.443 يورو. ايل فوندو rischi إد oneri هكتار الامم المتحدة importo باري اليورو 13.374. ط debiti سونو 180،947 €. ط ratei ه risconti attivi سونو باري اليورو 2.271. ط ratei ه risconti passivi سونو باري اليورو 1.864. I crediti الصفحة اليسرى ط SOCI سونو باري اليورو 17.630.

وهنا هو متغير آخر يستخدم وظيفة المولدات التي تعمل من أجل الأعداد الصحيحة: 

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

وفقط 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

وأنا أفضل الحل القائم على لغة لمشاريع حقيقية، ولكن أعتقد أن النهج مع استخدام الاحالة شريحة وتجدر الإشارة هنا: 

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)])

وهذا يعمل فقط من أجل الأعداد الصحيحة غير السالبة.

مرخصة بموجب: CC-BY-SA مع الإسناد
لا تنتمي إلى StackOverflow
scroll top