আমি পাইথন ২.6.১ এ হাজার হাজার বিভাজক হিসাবে কমা দিয়ে একটি পূর্ণসংখ্যা মুদ্রণের চেষ্টা করছি । উদাহরণস্বরূপ, আমি 1234567হিসাবে নম্বরটি দেখাতে চাই 1,234,567। আমি কীভাবে এটি করতে যাব? আমি গুগলে অনেকগুলি উদাহরণ দেখেছি, তবে আমি সহজতম ব্যবহারিক উপায়টি খুঁজছি।
পিরিয়ড এবং কমাগুলির মধ্যে সিদ্ধান্ত নেওয়ার জন্য এটি স্থানীয়-নির্দিষ্ট হওয়ার দরকার নেই। আমি যথাসম্ভব যথাসম্ভব সহজ কিছু পছন্দ করব।
উত্তর:
'{:,}'.format(value) # For Python ≥2.7
f'{value:,}' # For Python ≥3.6import 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প্রতি ফর্ম্যাট নির্দিষ্টকরণ মিনি-ভাষা ,
','বিকল্প একটি সহস্র বিভাজক জন্য একটি কমা ব্যবহার ইঙ্গিত। স্থানীয় সচেতন বিভাজকের জন্য,'n'পরিবর্তে পূর্ণসংখ্যার উপস্থাপনা প্রকারটি ব্যবহার করুন।
{val:,}.format(val=val)
f"{2 ** 64 - 1:,}"
আমি এটি কাজ করতে পেরেছি:
>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'en_US')
'en_US'
>>> locale.format("%d", 1255000, grouping=True)
'1,255,000'অবশ্যই, আপনার আন্তর্জাতিকীকরণের সহায়তার দরকার নেই তবে এটি স্পষ্ট, সংক্ষিপ্ত এবং একটি অন্তর্নির্মিত লাইব্রেরি ব্যবহার করে।
PS যে "% d" হ'ল স্বাভাবিক%-স্টাইল বিন্যাসক। আপনার কাছে কেবল একটি ফর্ম্যাটর থাকতে পারে তবে ক্ষেত্রের প্রস্থ এবং যথাযথ সেটিংসের ক্ষেত্রে এটি আপনার যা প্রয়োজন তা হতে পারে।
পিপিএস যদি আপনি 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)পুনরাবৃত্তি নেতিবাচক ক্ষেত্রে কার্যকর, কিন্তু কমা প্রতি একটি পুনরাবৃত্তি আমার কাছে কিছুটা অতিরিক্ত বলে মনে হচ্ছে।
locale, আমি এটি হিসাবে সামান্য ব্যবহার করতে পারেন।
setlocaleডিফল্ট ব্যবহারের জন্য '' ব্যবহার করতে পারেন, আশা করি উপযুক্ত হবে।
অদক্ষতা এবং অপঠনযোগ্যতার জন্য এটি পরাজিত করা শক্ত:
>>> 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('-,','-')lambda x: (lambda s: ','.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('-,','-'))(str(x))কেবল অবহেলা থিম রাখা।
অপ্রাসঙ্গিক অংশগুলি মুছে ফেলা এবং এটি কিছুটা পরিষ্কার করার পরে এখানে লোকেল গ্রুপিং কোডটি রয়েছে:
(নিম্নলিখিতটি কেবলমাত্র পূর্ণসংখ্যার জন্য কাজ করে)
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'এখানে ইতিমধ্যে কিছু ভাল উত্তর আছে। আমি কেবল ভবিষ্যতের রেফারেন্সের জন্য এটি যুক্ত করতে চাই। পাইথন ২.7-এ হাজার হাজার বিভাজকের জন্য একটি ফর্ম্যাট স্পেসিফায়ার হতে চলেছে। পাইথন ডক্স অনুসারে এটি এর মতো কাজ করে
>>> '{:20,.2f}'.format(f)
'18,446,744,073,709,551,616.00'পাইথন ৩.১ এ আপনি একই জিনিসটি করতে পারেন:
>>> format(1234567, ',d')
'1,234,567'আমি অবাক হয়েছি যে কেউ পাইনি বলেছে যে আপনি পাইথন ৩.6-তে এফ-স্ট্রিংগুলির সাহায্যে এটি এত সহজ:
>>> num = 10000000
>>> print(f"{num:,}")
10,000,000... যেখানে কোলনের পরে অংশটি বিন্যাস নির্দিষ্টকরণকারক। কমা হ'ল বিচ্ছেদী চরিত্রটি যা আপনি চান তাই f"{num:_}"কমা পরিবর্তে আন্ডারস্কোর ব্যবহার করেন।
এটি format(num, ",")পাইথন 3 এর পুরানো সংস্করণগুলির জন্য সমান ।
এখানে এক-লাইন রেজেক্স প্রতিস্থাপন:
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এটিই আমি ভাসমানদের জন্য করি। যদিও, সত্যি বলতে, আমি নিশ্চিত নই যে এটি কোন সংস্করণগুলির জন্য কাজ করে - আমি ২.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 )কোনও স্থানীয় প্রতিনিধিত্বের জন্যও ব্যবহার করতে পারেন । আমি মনে করি এটি স্থানীয় সমাধানের সহজতম উপায়।
আরো তথ্যের জন্য, অনুসন্ধান 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'আয়ান স্নাইডারের উত্তরটি সামান্যভাবে প্রসারিত করা:
আপনি যদি কাস্টম হাজার হাজার বিভাজক ব্যবহার করতে চান তবে সহজ সমাধানটি হ'ল:
'{:,}'.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'{:_.2f}'.format(12345.6789).replace('.', ',').replace('_', '.')
আমি নিশ্চিত যে এর জন্য অবশ্যই একটি স্ট্যান্ডার্ড লাইব্রেরি ফাংশন থাকতে হবে তবে এটি পুনরাবৃত্তি ব্যবহার করে নিজেই এটি লেখার চেষ্টা করা মজাদার ছিল তাই আমি এখানে যা এলাম তা এখানে:
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 আমি এই reworked:
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এটি নিয়মিত এক্সপ্রেশন বৈশিষ্ট্যটি ব্যবহার করে: তাকাতে অর্থাত্ (?=\d)নিশ্চিত করা যে কেবলমাত্র তিনটি সংখ্যার গোষ্ঠী যাতে 'পরে' একটি অঙ্ক রয়েছে তারাই কমা পান। আমি বলি 'পরে' কারণ স্ট্রিংটি এই সময়ে বিপরীত।
[::-1] শুধু একটি স্ট্রিং বিপরীত।
গৃহীত উত্তর ঠিক আছে, তবে আমি আসলে পছন্দ করি format(number,',')। আমার ব্যাখ্যা করা এবং মনে রাখা সহজ।
-
পূর্ণসংখ্যা (দশমিক ছাড়াই):
"{:,d}".format(1234567)
-
ভাসমান (দশমিক সহ):
"{:,.2f}".format(1234567)
যেখানে পূর্বে fসংখ্যা দশমিক জায়গাগুলির সংখ্যা নির্দিষ্ট করে।
-
বোনাস
ভারতীয় লক্ষ / কোটি নম্বর সিস্টেমের জন্য দ্রুত এবং মলিন স্টার্টার ফাংশন (12,34,567):
পাইথন সংস্করণ ২.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)এখানে কয়েকটি বিষয় লক্ষণীয়:
এবং আরও কঠোর সংস্করণ:
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)আমি পাইথন শিক্ষানবিস, তবে একজন অভিজ্ঞ প্রোগ্রামার। আমার পাইথন 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প্রথম সংস্করণটি আরও বুদ্ধিমান পছন্দ, আপনি যদি প্রোগ্রামটি বুঝতে চান তবে be
এখানে ভাসমানদের জন্য কাজ করে এমন একটি:
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'float2comma(12031023.1323)ফিরে আসে: '12, 031,023.132,3 '
পাইথন 2.5+ এবং পাইথন 3 (কেবল ধনাত্মক আন্ত) এর জন্য একটি লাইনার:
''.join(reversed([x + (',' if i and not i % 3 else '') for i, x in enumerate(reversed(str(1234567)))]))পূর্ববর্তী শীর্ষে পোষ্ট করা উত্তরের মধ্যে ডট বিভাজক নিয়ে আমি কিছু সমস্যা পেয়েছি। আমি একটি সর্বজনীন সমাধান ডিজাইন করেছি যেখানে আপনি লোকালটি পরিবর্তন না করে আপনি হাজার বিভাজক হিসাবে যা খুশি তা ব্যবহার করতে পারেন । আমি জানি এটি সবচেয়ে মার্জিত সমাধান নয়, তবে এটি কাজটি করে। এটি উন্নত নির্দ্বিধায়!
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এটি কমাগুলি সহ অর্থ উপার্জন করে
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 বছর পরে LOL) লোকেরা সম্ভবত অজগর ব্যবহার করবে 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 কোডটি কাজ করছে না I আমি ভাবছি বাক্য গঠনটি আলাদা)।
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 ব্যবহার করছি তাই বিল্ট-ইন ফর্ম্যাটিংটিতে আমার অ্যাক্সেস নেই।
আমি জ্যাঙ্গো কোড ইন্টকমমা (নীচের কোডে ইনটকমমা_রেচার) দেখেছি এবং বুঝতে পেরেছি এটি অকার্যকর, কারণ এটি পুনরাবৃত্তিযোগ্য এবং প্রতিটি রানে রেজেক্স সংকলন করাও ভাল জিনিস নয়। এটি 'ইস্যু'র প্রয়োজনীয় নয় কারণ জ্যাঙ্গো আসলে এই ধরণের নিম্ন-স্তরের পারফরম্যান্সের উপর দৃষ্টি নিবদ্ধ করে না। এছাড়াও, আমি পারফরম্যান্সের মধ্যে 10 পার্থক্যের একটি ফ্যাক্টরটি আশা করছিলাম তবে এটি কেবল 3 গুণ বেশি ধীর।
কৌতূহলের বাইরে আমি রেজেক্স ব্যবহার করার সময় পারফরম্যান্সের সুবিধাগুলি কী তা দেখার জন্য ইন্টারকোমার কয়েকটি সংস্করণ প্রয়োগ করেছি। আমার পরীক্ষার ডেটা এই কাজের জন্য সামান্য সুবিধা উপসংহারে পৌঁছেছে, তবে আশ্চর্যরকম কিছু নয়।
আমি যা সন্দেহ করেছি তা দেখে আমিও সন্তুষ্ট হয়েছিল: নো-রেজেক্স ক্ষেত্রে বিপরীত এক্সরঞ্জ পদ্ধতির ব্যবহার অপ্রয়োজনীয়, তবে এটি কোডটি 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এটি পিইপি -> https://www.python.org/dev/peps/pep-0378/ প্রতি পাইথন এ বেকড হয়
কয়েক হাজার বিভাজক সহ পূর্ণসংখ্যা দেখাতে কেবল বিন্যাস (1000, ', ডি') ব্যবহার করুন
পিইপিতে বর্ণিত আরও ফর্ম্যাট রয়েছে, এটি আছে
এখানে একটি জেনারেটর ফাংশন ব্যবহার করে আরও একটি বৈকল্পিক যা পূর্ণসংখ্যার জন্য কাজ করে:
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__repr__()ওভাররাইড করার সঠিক পদ্ধতিটি কি? আমি ওভাররাইড __str__()এবং __repr__()একা চলে যাওয়ার পরামর্শ দেব , কারণ int(repr(number(928374)))কাজ করা উচিত, তবে int()কমাতে দম বন্ধ হয়ে যাবে।
number(repr(number(928374)))হয় না, কার্যকর হয় না int(repr(number(928374)))। সর্বোপরি, এই পদ্ধতির সাথে সরাসরি কাজ করার জন্য print, যেমন ওপি অনুরোধ করেছে, __str__()পদ্ধতিটি বরং ওভাররাইড হওয়া উচিত __repr__()। নির্বিশেষে, মূল কমা সন্নিবেশ যুক্তিটিতে একটি বাগ রয়েছে বলে মনে হচ্ছে।
ইতালি:
>>> import locale
>>> locale.setlocale(locale.LC_ALL,"")
'Italian_Italy.1252'
>>> f"{1000:n}"
'1.000'ভাসমানদের জন্য:
float(filter(lambda x: x!=',', '1,234.52'))
# returns 1234.52Ints জন্য:
int(filter(lambda x: x!=',', '1,234'))
# returns 1234float('1,234.52'.translate(None, ','))আরও সহজবোধ্য এবং সম্ভবত দ্রুত হতে পারে।