During phash computation original image is resized. hashSize parameter basically controls height and width of resized image.

Algorithm can be found here. Implementation of the first step (reduce size):

image = image.convert("L").resize((hash_size, hash_size), Image.ANTIALIAS)

See sources of imagehash.phash

Lets see what the line imghash3.append(bin( int(imghash2, 16))[2:].zfill(64)) does.

In [16]: imghash2 = '11b97c7eb158ac'

First of all it converts hexadecimal string into integer

In [17]: int(imghash2, 16)
Out[17]: 4989018956716204

The builtin bin function is applied to convert the integer into a binary string

In [18]: bin( int(imghash2, 16))
Out[18]: '0b10001101110010111110001111110101100010101100010101100'

Drops first two characters using list slice

In [19]: bin( int(imghash2, 16))[2:]
Out[19]: '10001101110010111110001111110101100010101100010101100'

Adds 0 on the left side to make a string of 64 characters total

In [20]: bin( int(imghash2, 16))[2:].zfill(64)
Out[20]: '0000000000010001101110010111110001111110101100010101100010101100'

Yes, there are the string justification methods, ljust and rjust.

>>> '12'.rjust(5, '#')
'###12'
>>> 'txt'.rjust(5, ' ')
'  txt'
>>> '12'.ljust(5, '#')
'12###'

there is no inbuilt zfill but I use this zfl function

def zfl(s, width):
# Pads the provided string with leading 0's to suit the specified 'chrs' length
# Force # characters, fill with leading 0's
return '{:0>{w}}'.format(s, w=width)

This might be useful to you? Just pass the string and the string width you require.

You don't need zfill:

s = f"{c:05d}_keypoints"

Python zfill implementation lives here.

Here is is relatively apparent that the implementation is primarily composed of an allocation and memset/memcpy, with the rest being very simple addition/subtraction.

The big-O of these operations are platform/implementation/circumstance driven and often not that depended on the length of the string (They might happen instantaneous. They might allocate a new page for heap and request access to extra memory from an external services taking a few second). But for your purposes I would act like it is O(n), where n is the size of the resulting string, since that is probably what memset/memcpy have (as discussed here alloc is not really measurable).

But in truth, you probably shouldn't worry about this, since there is nothing you can do to change it. A manually implementation would certainly be slower.

You can use format string syntax 02.

change the line : print(*range(1,n+1)) to print(*(f"{i:02}" for i in range(1, n + 1)))

Full code:

n = 15
for i in range(1, n + 1):
    print(*(f"{i:02}" for i in range(1, n + 1)))
    n = n - 1

output:

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
01 02 03 04 05 06 07 08 09 10 11 12 13 14
01 02 03 04 05 06 07 08 09 10 11 12 13
01 02 03 04 05 06 07 08 09 10 11 12
01 02 03 04 05 06 07 08 09 10 11
01 02 03 04 05 06 07 08 09 10
01 02 03 04 05 06 07 08 09
01 02 03 04 05 06 07 08
01 02 03 04 05 06 07
01 02 03 04 05 06
01 02 03 04 05
01 02 03 04
01 02 03
01 02
01

Another option is to use zfill like :

print(*(str(i).zfill(2) for i in range(1, n + 1)))

you need to convert the i into str because zfill is a method of string objects.

You could use str.format:

def formatBusinessCodes(code):
    """ Function that formats business codes.  Pass in a business code which will convert to a string with 6 digits """
    return '{:06d}'.format(code)

In [23]: formatBusinessCodes(1)
Out[25]: '000001'

In [26]: formatBusinessCodes(10)
Out[26]: '000010'

In [27]: formatBusinessCodes(123)
Out[27]: '000123'

The format {:06d} can be understood as follows:

• {...} means replace the following with an argument from format, (e.g. code).
• : begins the format specification
• 0 enables zero-padding
• 6 is the width of the string. Note that numbers larger than 6 digits will NOT be truncated, however.
• d means the argument (e.g. code) should be of integer type.

Note in Python2.6 the format string needs an extra 0:

def formatBusinessCodes(code):
    """ Function that formats business codes.  Pass in a business code which will convert to a string with 6 digits """
    return '{0:06d}'.format(code)

The behaviour is correct. zfill(x) itself always return a string that is at least as long as the original string and with at least x characters. It's % that is shortening it by replacing %.2f with a shorter string:

>>> "%.2x" % 255
'ff'

Since ff is shorter than %.2x you end up with less characters.

Keep in mind that zfill knows nothing about the formatting specifiers and thus:

>>> "%.2x".zfill(8)
'0000%.2x'

as you can see the %.2x remains untouched and the later call to % replaces it with just ff shortening the string.

You have to call zfill afterwards:

>>> ("%.2x" % 255).zfill(8)
'000000ff'

Also note that you can avoid callinf zfill and doing everything with the string formatting:

>>> "%08.2x" % 255
'000000ff'

The 0 is the filling character and the 8 is the width of the string.

Side note: specifying both a total width of 8 and a precision of 2 is actually useless. The only effect of specifying .2x is to add a 0 in front of numbers less than 16:

>>> "%.2x" % 5
'05'
>>> "%.2x" % 10
'0a'

It does not have any effect when the numbers are bigger:

>>> "%.2x" % 16
'10'
>>> "%x" % 16
'10'

And the 8 zero-fill would add that 0 anyway, so the format specifier %08.2x is exactly equivalent to just %08x.

You are doing zfill on list object. Instead, you need to perform zfill on each item of list. Below is the sample example for range 10:

>>> a = range(0, 10)

#                 v  this value represent the count of zeros
#                 v  It should be `7` in your case
>>> [str(i).zfill(10) for i in a]
['0000000000', '0000000001', '0000000002', '0000000003', '0000000004', '0000000005', '0000000006', '0000000007', '0000000008', '0000000009']

As per the str.zfill() document:

string.zfill(s, width)

Pad a numeric string s on the left with zero digits until the given width is reached. Strings starting with a sign are handled correctly.

You're zfilling the constants used for your back-reference which are two characters already (\ and an int), leaving no space for an extra zero for the first character, and just one space for the second character.

You can instead pass a function as your replacement to re.sub and do the zfilling in there:

def repl_fn(m):
  return f'-{m.group(1).zfill(2)}-{m.group(2).zfill(3)}-'

result = re.sub(pattern, repl_fn, string)
print(result)
# -07-008-

The zfilling is now done at replacement time, not before, as in your code.

zfill is a method of strings, not integers:

x = 12345
print(str(x).zfill(10))

As maybe a alternative more portable [1] and efficient [2], actually you can just use str.ljust.

In [2]: '190'.ljust(8, '0')
Out[2]: '19000000'

In [3]: str.ljust?
Docstring:
S.ljust(width[, fillchar]) -> str

Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
Type:      method_descriptor

[1] format is not present on old python versions. format specifier was added since Python 3.0 (see PEP 3101) and Python 2.6.

[2] reverse twice is an expensive operation.

The answer depends on the used data types by pandas. You can check this printing df.dtypes.

If all data types are integers, than this will work:

import pandas as pd
df = pd.DataFrame([[1.0, 2, 3],[4,5,6], [6,7,8], [11,22,33]], columns=['A', 'B', 'C'])
df[['A','B']] = df[['A','B']].apply(lambda x: x.astype(str).str.zfill(2))

If at least on value is of type float, you have to convert the value to an integer first, than to a string and call zfill() afterwards.

df = pd.DataFrame([[1.0, 2, 3],[4,5,6], [6,7,8], [11,22,33]], columns=['A', 'B', 'C'])
df.dtypes
df[['A','B']] = df[['A','B']].apply(lambda x: x.astype(int).astype(str).str.zfill(2))

In both cases the output is

    A   B   C
0  01  02   3
1  04  05   6
2  06  07   8
3  11  22  33

This answer is only an extention of the first one by Mondaa.

Considering you have only two choices (Metric, Imperial) to choose from, you could use Numpy where.

Input sample.csv

       Unit  closing
0  Imperial       20
1    Metric      284
2  Imperial     1451
3  Imperial       45
4    Metric     8491

import pandas as pd
import numpy as np

df = pd.read_csv('sample.csv')

df['closing'] = np.where(df['Unit'] == 'Metric',
     df['closing'].astype(str).str.zfill(5),
     df['closing'].astype(str).str.zfill(4),
)

print(df)

Output from df

       Unit closing
0  Imperial    0020
1    Metric   00284
2  Imperial    1451
3  Imperial    0045
4    Metric   08491

What you are doing is turning sample into a string representation of the list then using zfill on it.

You need to apply the zfill to all the elements. Use a list comprehension for this.

res = [s.zfill(8) for s in sample]

You probably have empty space in the end try str.strip().str.zfill(12)

Ex:

import pandas as pd

df = pd.DataFrame({"SampleNumber": ['000000002131', '0000dsda2123', '0000eew12341', "wewqsws1'  ", '000000000123']})
df['SampleNumber'] = df['SampleNumber'].str.strip().str.zfill(12)
print(df)