You can use string formatting for this purpose:

>>> "0x{:02x}".format(13)
'0x0d'

>>> "0x{:02x}".format(131)
'0x83'

Edit: Your code suggests that you are trying to convert a string to a hexstring representation. There is a much easier way to do this (Python2.x):

>>> "abcd".encode("hex")
'61626364'

An alternative (that also works in Python 3.x) is the function binascii.hexlify().

Use the format() function with a '02x' format.

>>> format(255, '02x')
'ff'
>>> format(2, '02x')
'02'

The 02 part tells format() to use at least 2 digits and to use zeros to pad it to length, x means lower-case hexadecimal.

The Format Specification Mini Language also gives you X for uppercase hex output, and you can prefix the field width with # to include a 0x or 0X prefix (depending on wether you used x or X as the formatter). Just take into account that you need to adjust the field width to allow for those extra 2 characters:

>>> format(255, '02X')
'FF'
>>> format(255, '#04x')
'0xff'
>>> format(255, '#04X')
'0XFF'

In python3, use this f string format:

f"0x{variable:02x}"

For maximum python2/3 compatibility, use .format():

"0x{:02x}".format(variable)

Just for completeness, using the modern .format() syntax:

>>> numbers = [1, 15, 255]
>>> ''.join('{:02X}'.format(a) for a in numbers)
'010FFF'

Use the format() function:

format(addrint, '#04x')

This formats the input value as a 2 digit hexadecimal string with leading zeros to make up the length, and # includes the 'standard prefix', 0x in this case. Note that the width of 4 includes that prefix. x produces lower-case hex strings; use X if you need uppercase.

Demo:

>>> for i in range(8, 12):
...     print format(i, '#04x')
... 
0x08
0x09
0x0a
0x0b

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

TL;DR (Python 3.6+)

print(f'Number {x:02x}')

This is explained in the Format specification Mini-Language.

To get uppercase letters:

'x' Hex format. Outputs the number in base 16, using lowercase letters for the digits above 9.

'X' Hex format. Outputs the number in base 16, using uppercase letters for the digits above 9.

To get 2 digits:

width is a decimal integer defining the minimum field width. If not specified, then the field width will be determined by the content.

When no explicit alignment is given, preceding the width field by a zero ('0') character enables sign-aware zero-padding for numeric types. This is equivalent to a fill character of '0' with an alignment type of '='.

So, you either need to set the width to 2, the fill to 0, and the alignment to =, or, more simply, just use the special 0 prefix before the width.

So:

print('Number '+'{0:02X}'.format(int(x)))

While we're at it, this is pretty silly code.

First, x is already an int, so why call int on it?

print('Number '+'{0:02X}'.format(x))

Meanwhile, if the only thing you're putting in a format string is a single format specifier, you don't need str.format, just format:

print('Number ' + format(x, '02X'))

Or, alternatively, the whole point of str.format is that you can throw multiple things into one format string:

print('Number {:02X}'.format(x))

If you are using >= Python 3.6, you can use elegant f-strings:

print(f'Number {x:02x}')