නූලකට ශුන්‍ය පෑඩ් කරන්නේ කෙසේද?

සංඛ්‍යාත්මක නූලක් වමට ශුන්‍යයන් සහිත පෑඩ් කිරීම සඳහා පයිතොනික් ක්‍රමයක් යනු කුමක්ද, එනම් සංඛ්‍යාත්මක නූලට නිශ්චිත දිගක් තිබේද?

නූල්:

>>> 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
004

සංගීත හැඩතල ගැන්වීමේ ලියකියවිලි .

නූල් වස්තුවෙහි rjust ක්‍රමය භාවිතා කරන්න .

මෙම උදාහරණය මඟින් අක්ෂර 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'))

නූල් හැඩතල ගැන්වීම සහ එෆ්-නූල් සඳහා ප්‍රලේඛනය .

F-string භාවිතා කරන පයිතන් 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'

str(n).zfill(width)strings, ints, floats සමඟ ක්‍රියා කරනු ඇති අතර එය පයිතන් 2. x සහ 3. x අනුකූල වේ:

>>> n = 3
>>> str(n).zfill(5)
'00003'
>>> n = '3'
>>> str(n).zfill(5)
'00003'
>>> n = '3.0'
>>> str(n).zfill(5)
'003.0'

ඉක්මන් පිළිතුරක් නොව තේරුම් ගැනීමට මෙහි පැමිණි අයට. මම මේවා විශේෂයෙන් කරන්නේ කාල නූල් සඳහා ය:

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" පෑඩින් අක්ෂර සමඟ ආදේශ කළ යුතු දේ, පෙරනිමිය හිස් අවකාශයකි

">" සංකේත මගින් 2 "0" අක්ෂර සියල්ලම නූල් වල වමට සම්බන්ධ කරයි

":" format_spec සංකේතවත් කරයි

සංඛ්‍යාත්මක නූලක් වමට ශුන්‍යයන් සහිත පෑඩ් කිරීමට වඩාත්ම පයිතොනික් ක්‍රමය කුමක්ද, එනම් සංඛ්‍යාත්මක නූලට නිශ්චිත දිගක් තිබේද?

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

එය එකම දිගක් හෝ දිගු ද යන්න පරීක්ෂා කරයි, එම අවස්ථාවේ දී එය නූල නැවත ලබා දෙයි.

>>> '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()IMNSHO, එය වඩා හොඳින් කියවන නිසාත්, මම 1980 ජනවාරි සිට එම අංකනය භාවිතා කර ඇති නිසාත්, මම තවමත් පැරණි පාසල් ශෛලියට වැඩි කැමැත්තක් දක්වන බව සලකන්න . යමක් ... පැරණි බල්ලන් .. යමක් ... නව උපක්‍රම.

පයිතන් භාවිතා කරන විට >= 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'

පූර්ණ සංඛ්‍යා ලෙස සුරකින ලද zip කේත සඳහා:

>>> a = 6340
>>> b = 90210
>>> print '%05d' % a
06340
>>> print '%05d' % b
90210

ඉක්මන් කාල සංසන්දනය:

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

එහි හරි:

 h = 2
 m = 7
 s = 3
 print("%02d:%02d:%02d" % (h, m, s))

එබැවින් ප්‍රතිදානය වනුයේ: "02:07:03"

මම ශ්‍රිතයක් කළා:

def PadNumber(number, n_pad, add_prefix=None):
    number_str = str(number)
    paded_number = number_str.zfill(n_pad)
    if add_prefix:
        paded_number = add_prefix+paded_number
    print(paded_number)

PadNumber(99, 4)
PadNumber(1011, 8, "b'")
PadNumber('7BEF', 6, "#")

ප්‍රතිදානය:

0099
b'00001011
#007BEF

එෆ්-නූලක් ඇතුළත නූලක දිගකින් int භාවිතා කරන්නේ කෙසේදැයි මම එකතු කරමි.

>>> pad_number = len("this_string")
11
>>> s = f"{1:0{pad_number}}" }
>>> s
'00000000001'

ඔබට "0" නැවත නැවත කළ හැකිය, එය str(n)සූදානම් කර දකුණු පළල පෙත්තක් ලබා ගන්න. ඉක්මන් හා අපිරිසිදු කුඩා ප්‍රකාශනය.

def pad_left(n, width, pad="0"):
    return ((pad * width) + str(n))[-width:]