Starting with Python 3.6, you can:

>>> value = 42
>>> padding = 6
>>> f"{value:#0{padding}x}"
'0x002a'

Note the padding includes the 0x. If you don't want that you can do

>>> f"0x{value:0{padding}x}"
'0x00002a'

for older python versions use the .format() string method:

>>> "{0:#0{1}x}".format(42,6)
'0x002a'

Explanation:

{   # Format identifier
0:  # first parameter
#   # use "0x" prefix
0   # fill with zeroes
{1} # to a length of n characters (including 0x), defined by the second parameter
x   # hexadecimal number, using lowercase letters for a-f
}   # End of format identifier

If you want the letter hex digits uppercase but the prefix with a lowercase 'x', you'll need a slight workaround:

>>> '0x{0:0{1}X}'.format(42,4)
'0x002A'

Perhaps you're looking for the .zfill method on strings. From the docs:

Help on built-in function zfill:

zfill(...)
    S.zfill(width) -> string

    Pad a numeric string S with zeros on the left, to fill a field
    of the specified width.  The string S is never truncated.

Your code can be written as:

def padhexa(s):
    return '0x' + s[2:].zfill(8)

assert '0x00000123' == padhexa('0x123')
assert '0x00ABCD12' == padhexa('0xABCD12')
assert '0x12345678' == padhexa('0x12345678')

This is happening because hex() will not include any leading zeros, for example:

>>> hex(15)[2:]
'f'

To make sure you always get two characters, you can use str.zfill() to add a leading zero when necessary:

>>> hex(15)[2:].zfill(2)
'0f'

Here is what it would look like in your code:

fc = '0x'
for i in b[0x15c:0x15f]:
    fc += hex(ord(i))[2:].zfill(2)

The total number of hex digits you want, starting from binary string b, is

hd = (len(b) + 3) // 4

So...:

x = '%.*x' % (hd, int('0b'+b, 0))

should give you what you want (with a '0x' prefix that you can easily slice away of course, just use x[2:]).

Added: the format string '%.*x' means "format as hexadecimal to a length as per supplied parameter, with leading zeros". The "supplied parameter" here is hd, the total number of hex digits we require.

The simple, key concept is to think in terms of total number of digits (binary on input, hex on output) rather than the "number of leading zeros" in each case -- the latter will just fall into place. E.g, if the input binary string has 576 bits, no matter how many of them are "leading zeros", you want the output hex string to have 576 // 4, i.e, 144, hex digits, so that's what hd will be set to -- and that's how many digits you'll get by this formatting (as many of them will be "leading zeros" as needed -- no more, no less).

You should not always have leading zeroes, such as if the first character of the input is F.