বামে শূন্যের সাথে সংখ্যার স্ট্রিং প্যাড করার পাইথোনিক উপায় কী, অর্থাত্ সংখ্যার স্ট্রিংটির একটি নির্দিষ্ট দৈর্ঘ্য রয়েছে?
বামে শূন্যের সাথে সংখ্যার স্ট্রিং প্যাড করার পাইথোনিক উপায় কী, অর্থাত্ সংখ্যার স্ট্রিংটির একটি নির্দিষ্ট দৈর্ঘ্য রয়েছে?
উত্তর:
স্ট্রিংস:
>>> n = '4'
>>> print(n.zfill(3))
004এবং সংখ্যার জন্য:
>>> n = 4
>>> print(f'{n:03}') # Preferred method, python >= 3.6
004
>>> print('%03d' % n)
004
>>> print(format(n, '03')) # python >= 2.6
004
>>> print('{0:03d}'.format(n)) # python >= 2.6 + python 3
004
>>> print('{foo:03d}'.format(foo=n)) # python >= 2.6 + python 3
004
>>> print('{:03d}'.format(n)) # python >= 2.7 + python3
004python >= 2.6ভুল। এই সিনট্যাক্সটি কাজ করে না python >= 3। আপনি এটিতে পরিবর্তন করতে পারেন python < 3, তবে আমি কি পরিবর্তে সর্বদা বন্ধনী ব্যবহার এবং মন্তব্যগুলি পুরোপুরি বাদ দিতে (প্রস্তাবিত ব্যবহারকে উত্সাহিত করতে) পরামর্শ দিতে পারি?
'{:03d} {:03d}'.format(1, 2)স্পষ্টতই মানগুলি ক্রম অনুসারে বরাদ্দ করেছে।
printবক্তব্যটি বোঝানো হয়েছিল , যখন printপাইথন 3 এ কোনও ফাংশন হওয়া উচিত ? আমি পেরেন্সে সম্পাদনা করেছি; যেহেতু শুধুমাত্র একটি জিনিস মুদ্রিত হচ্ছে, এটি এখন পাই 2 এবং পাই 3 এ অভিন্নভাবে কাজ করে।
কেবল স্ট্রিং অবজেক্টের রড পদ্ধতিটি ব্যবহার করুন ।
এই উদাহরণটি 10 অক্ষরের দীর্ঘ স্ট্রিং তৈরি করবে, প্রয়োজনীয়ভাবে প্যাডিং করবে।
>>> t = 'test'
>>> t.rjust(10, '0')
>>> '000000test'এছাড়াও zfill, আপনি সাধারণ স্ট্রিং ফর্ম্যাটিং ব্যবহার করতে পারেন:
print(f'{number:05d}') # (since Python 3.6), or
print('{:05d}'.format(number)) # or
print('{0:05d}'.format(number)) # or (explicit 0th positional arg. selection)
print('{n:05d}'.format(n=number)) # or (explicit `n` keyword arg. selection)
print(format(number, '05d'))স্ট্রিং ফর্ম্যাটিং এবং এফ-স্ট্রিংয়ের জন্য ডকুমেন্টেশন ।
formatপরিবর্তে ব্যবহার করতে বলে এবং লোকেরা সাধারণত এটি হ্রাস করার উদ্দেশ্যে ব্যাখ্যা করে।
পাইথন 3.6+ এর জন্য এফ-স্ট্রিংগুলি ব্যবহার করে:
>>> i = 1
>>> f"{i:0>2}" # Works for both numbers and strings.
'01'
>>> f"{i:02}" # Works only for numbers.
'01'পাইথন 2 থেকে পাইথন 3.5:
>>> "{:0>2}".format("1") # Works for both numbers and strings.
'01'
>>> "{:02}".format(1) # Works only for numbers.
'01'>>> '99'.zfill(5)
'00099'
>>> '99'.rjust(5,'0')
'00099'আপনি যদি বিপরীত চান:
>>> '99'.ljust(5,'0')
'99000'যারা এখানে এসেছেন তাদের জন্য কেবল একটি দ্রুত উত্তর নয়। আমি বিশেষত সময়ের স্ট্রিংয়ের জন্য এগুলি করি:
hour = 4
minute = 3
"{:0>2}:{:0>2}".format(hour,minute)
# prints 04:03
"{:0>3}:{:0>5}".format(hour,minute)
# prints '004:00003'
"{:0<3}:{:0<5}".format(hour,minute)
# prints '400:30000'
"{:$<3}:{:#<5}".format(hour,minute)
# prints '4$$:3####'"0" চিহ্নগুলি "2" প্যাডিং অক্ষরগুলির সাথে কী প্রতিস্থাপন করবে তা ডিফল্ট একটি খালি স্থান
">" চিহ্নগুলি সমস্ত "" 0 "অক্ষরটিকে স্ট্রিংয়ের বামে সংযুক্ত করে
":" ফর্ম্যাট_স্পেক প্রতীক
বামদিকে শূন্যের সাথে সংখ্যার স্ট্রিং প্যাড করার সর্বাধিক অজগর উপায় কী, তাই সংখ্যার স্ট্রিংটির একটি নির্দিষ্ট দৈর্ঘ্য থাকে?
str.zfill এটি করার জন্য বিশেষভাবে উদ্দেশ্য:
>>> '1'.zfill(4)
'0001'নোট করুন যে এটি বিশেষভাবে অনুরোধ অনুযায়ী সংখ্যাযুক্ত স্ট্রিংগুলি পরিচালনা করার উদ্দেশ্যে এবং স্ট্রিংয়ের শুরুতে একটি +বা সরানো -:
>>> '+1'.zfill(4)
'+001'
>>> '-1'.zfill(4)
'-001'এখানে সহায়তা দেওয়া আছে str.zfill:
>>> help(str.zfill)
Help on method_descriptor:
zfill(...)
S.zfill(width) -> str
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.এটি বিকল্প পদ্ধতির সর্বাধিক সম্পাদনকারী:
>>> min(timeit.repeat(lambda: '1'.zfill(4)))
0.18824880896136165
>>> min(timeit.repeat(lambda: '1'.rjust(4, '0')))
0.2104538488201797
>>> min(timeit.repeat(lambda: f'{1:04}'))
0.32585487607866526
>>> min(timeit.repeat(lambda: '{:04}'.format(1)))
0.34988890308886766%পদ্ধতির জন্য আপেলের সাথে আপেলকে সর্বোত্তম তুলনা করতে (নোট করুন এটি আসলে ধীরে ধীরে), যা অন্যথায় প্রাক-গণনা করবে:
>>> min(timeit.repeat(lambda: '1'.zfill(0 or 4)))
0.19728074967861176
>>> min(timeit.repeat(lambda: '%04d' % (0 or 1)))
0.2347015216946602কিছুটা খনন করে, আমি zfillপদ্ধতিটির প্রয়োগটি এখানে পেয়েছি Objects/stringlib/transmogrify.h:
static PyObject *
stringlib_zfill(PyObject *self, PyObject *args)
{
Py_ssize_t fill;
PyObject *s;
char *p;
Py_ssize_t width;
if (!PyArg_ParseTuple(args, "n:zfill", &width))
return NULL;
if (STRINGLIB_LEN(self) >= width) {
return return_self(self);
}
fill = width - STRINGLIB_LEN(self);
s = pad(self, fill, 0, '0');
if (s == NULL)
return NULL;
p = STRINGLIB_STR(s);
if (p[fill] == '+' || p[fill] == '-') {
/* move sign to beginning of string */
p[0] = p[fill];
p[fill] = '0';
}
return s;
}আসুন এই সি কোড দিয়ে চলুন।
এটি প্রথমে অবস্থানগতভাবে যুক্তিকে পার্স করে, অর্থ এটি কীওয়ার্ড আর্গুমেন্টকে মঞ্জুরি দেয় না:
>>> '1'.zfill(width=4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: zfill() takes no keyword argumentsএটি এটি একই দৈর্ঘ্য বা তার চেয়ে বেশি দীর্ঘ কিনা তা পরীক্ষা করে which
>>> '1'.zfill(0)
'1'zfillকল pad(এই padফাংশন এছাড়াও দ্বারা বলা হয় ljust, rjustএবং centerসেইসাথে)। এটি মূলত বিষয়বস্তুগুলিকে একটি নতুন স্ট্রিংয়ে অনুলিপি করে এবং প্যাডিংয়ে পূরণ করে।
static inline PyObject *
pad(PyObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
{
PyObject *u;
if (left < 0)
left = 0;
if (right < 0)
right = 0;
if (left == 0 && right == 0) {
return return_self(self);
}
u = STRINGLIB_NEW(NULL, left + STRINGLIB_LEN(self) + right);
if (u) {
if (left)
memset(STRINGLIB_STR(u), fill, left);
memcpy(STRINGLIB_STR(u) + left,
STRINGLIB_STR(self),
STRINGLIB_LEN(self));
if (right)
memset(STRINGLIB_STR(u) + left + STRINGLIB_LEN(self),
fill, right);
}
return u;
}কল করার পরে pad, zfillপূর্বের কোনওটি +বা -স্ট্রিংয়ের শুরুতে সরানো হয়।
নোট করুন যে মূল স্ট্রিংয়ের জন্য আসলে সংখ্যার প্রয়োজন হয় না:
>>> '+foo'.zfill(10)
'+000000foo'
>>> '-foo'.zfill(10)
'-000000foo'+এবং এর সাথে আচরণের কথা মাথায় রেখে -এবং আমি ডক্সে একটি লিঙ্ক যুক্ত করেছি!
width = 10
x = 5
print "%0*d" % (width, x)
> 0000000005সমস্ত উত্তেজনাপূর্ণ বিবরণের জন্য মুদ্রণ ডকুমেন্টেশন দেখুন!
পাইথন 3.x এর জন্য আপডেট (7.5 বছর পরে)
শেষ লাইনটি এখন হওয়া উচিত:
print("%0*d" % (width, x))অর্থাত্ print()এখন একটি ফাংশন, বিবৃতি নয়। নোট করুন যে আমি এখনও ওল্ড স্কুল printf()স্টাইল পছন্দ করি কারণ আইএমএনএসএইচও, এটি আরও ভাল পড়ে এবং কারণ ওম, আমি ১৯৮০ সালের জানুয়ারী থেকে এই স্বরলিপিটি ব্যবহার করছি Some কিছু ... পুরানো কুকুর .. কিছু নতুন কৌশল।
"%0*d" % (width, x)করে অজগর দ্বারা ব্যাখ্যা করা যায় সে সম্পর্কে আরও ব্যাখ্যা দিতে পারেন ?
পাইথন ব্যবহার করার সময় >= 3.6, সবচেয়ে পরিষ্কার উপায় স্ট্রিং ফর্ম্যাটিং সহ এফ-স্ট্রিংগুলি ব্যবহার করা :
>>> s = f"{1:08}" # inline with int
>>> s
'00000001'>>> s = f"{'1':0>8}" # inline with str
>>> s
'00000001'>>> n = 1
>>> s = f"{n:08}" # int variable
>>> s
'00000001'>>> c = "1"
>>> s = f"{c:0>8}" # str variable
>>> s
'00000001'আমি একটির সাথে ফর্ম্যাট করতে পছন্দ করব int, কেবল তখনই সাইনটি সঠিকভাবে পরিচালনা করা হয়:
>>> f"{-1:08}"
'-0000001'
>>> f"{1:+08}"
'+0000001'
>>> f"{'-1':0>8}"
'000000-1'দ্রুত সময়ের তুলনা:
setup = '''
from random import randint
def test_1():
num = randint(0,1000000)
return str(num).zfill(7)
def test_2():
num = randint(0,1000000)
return format(num, '07')
def test_3():
num = randint(0,1000000)
return '{0:07d}'.format(num)
def test_4():
num = randint(0,1000000)
return format(num, '07d')
def test_5():
num = randint(0,1000000)
return '{:07d}'.format(num)
def test_6():
num = randint(0,1000000)
return '{x:07d}'.format(x=num)
def test_7():
num = randint(0,1000000)
return str(num).rjust(7, '0')
'''
import timeit
print timeit.Timer("test_1()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_2()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_3()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_4()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_5()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_6()", setup=setup).repeat(3, 900000)
print timeit.Timer("test_7()", setup=setup).repeat(3, 900000)
> [2.281613943830961, 2.2719342631547077, 2.261691106209631]
> [2.311480238815406, 2.318420542148333, 2.3552384305184493]
> [2.3824197456864304, 2.3457239951596485, 2.3353268829498646]
> [2.312442972404032, 2.318053102249902, 2.3054072168069872]
> [2.3482314132374853, 2.3403386400002475, 2.330108825844775]
> [2.424549090688892, 2.4346475296851438, 2.429691196530058]
> [2.3259756401716487, 2.333549212826732, 2.32049893822186]আমি বিভিন্ন পুনরাবৃত্তির বিভিন্ন পরীক্ষা করেছি। পার্থক্যগুলি বিশাল নয়, তবে সমস্ত পরীক্ষায় zfillসমাধানটি সবচেয়ে দ্রুত ছিল।
আর একটি পদ্ধতির দৈর্ঘ্যের জন্য শর্ত যাচাইয়ের সাথে তালিকার বোঝাপড়া ব্যবহার করা হবে। নীচে একটি বিক্ষোভ প্রদর্শন করা হচ্ছে:
# input list of strings that we want to prepend zeros
In [71]: list_of_str = ["101010", "10101010", "11110", "0000"]
# prepend zeros to make each string to length 8, if length of string is less than 8
In [83]: ["0"*(8-len(s)) + s if len(s) < desired_len else s for s in list_of_str]
Out[83]: ['00101010', '10101010', '00011110', '00000000']আপনি "0" পুনরাবৃত্তিও করতে পারেন, এটিকে প্রেন্ডিং করতে str(n)এবং ডানদিকের প্রস্থের স্লাইস পেতে পারেন। দ্রুত এবং নোংরা সামান্য অভিব্যক্তি।
def pad_left(n, width, pad="0"):
return ((pad * width) + str(n))[-width:]