In n-bit two's complement, bits have value:

bit 0 = 2⁰
bit 1 = 2¹
bit n-2 = 2^n-2
bit n-1 = -2^n-1

But bit n-1 has value 2^n-1 when unsigned, so the number is 2ⁿ too high. Subtract 2ⁿ if bit n-1 is set:

def twos_complement(hexstr, bits):
    value = int(hexstr, 16)
    if value & (1 << (bits - 1)):
        value -= 1 << bits
    return value

print(twos_complement('FFFE', 16))
print(twos_complement('7FFF', 16))
print(twos_complement('7F', 8))
print(twos_complement('FF', 8))

Output:

-2
32767
127
-1

This will do the trick:

>>> print(hex (-1 & 0xffffffff))
0xffffffff

or, a variant that always returns fixed size (there may well be a better way to do this):

>>> def hex3(n):
...     return "0x%s"%("00000000%s"%(hex(n&0xffffffff)[2:-1]))[-8:]
...
>>> print hex3(-1)
0xffffffff
>>> print hex3(17)
0x00000011

Or, avoiding the hex() altogether, thanks to Ignacio and bobince:

def hex2(n):
    return "0x%x"%(n&0xffffffff)

def hex3(n):
    return "0x%s"%("00000000%x"%(n&0xffffffff))[-8:]

If you want to convert it to 64-bit signed integer then you can still use struct and pack it as unsigned integer ('Q'), then unpack as signed ('q'):

>>> struct.unpack('<q', struct.pack('<Q', int('0xb69958096aff3148', 16)))
(-5289099489896877752,)

Python converts FFFF at 'face value', to decimal 65535

input = 'FFFF'
val = int(input,16) # is 65535

You want it interpreted as a 16-bit signed number. The code below will take the lower 16 bits of any number, and 'sign-extend', i.e. interpret as a 16-bit signed value and deliver the corresponding integer

val16 = ((val+0x8000)&0xFFFF) - 0x8000

This is easily generalized

def sxtn( x, bits ):
     h= 1<<(bits-1)
     m = (1<<bits)-1
     return ((x+h) & m)-h

You can interpret the bytes as a two's complement signed integer using bitwise operations. For example, for a 16-bit number:

def s16(value):
    return -(value & 0x8000) | (value & 0x7fff)

Therefore:

>>> s16(int('0xffd2', 16))
-46
>>> s16(int('0xffcb', 16))
-53
>>> s16(int('0xffcc', 16))
-52
>>> s16(int('0x10', 16))
16
>>> s16(int('0xd', 16))
13
>>> s16(int('0x0', 16))
0
>>> s16(int('0xfffe', 16))
-2

This can be extended to any bit-length string, by setting the masks so the first mask matches the most-significant bit (0x8000 == 1 << 15 == 0b1000000000000000) and the second mask matches the all the remaining bits (0x7fff == (1 << 15) - 1 == 0b0111111111111111).

Here's a way (for 16 bit numbers):

>>> x=-123
>>> hex(((abs(x) ^ 0xffff) + 1) & 0xffff)
'0xff85'

(Might not be the most elegant way, though)

your function is designed for a 16-bit number with a value range of −32.768 (0x8000) to 32.767 (0x7fff), while 0xf1 is only a 8-bit number with a value range of -128 (0x80) to 127 (0x7f). Thus, the return statement in the function doesn't apply correctly.

You have to change the function according to what is the number of bits in your hex number. For 8-bit:

def get_8bit_signed_value(value):
    return -(value & 0x80) | (value & 0x7f)

Then

get_8bit_signed_value(int('0xf1', 16))

returns your desired -15 for 0xf1. You can automate this function for bitnumbers with nbits digits by calculating the value range limits by 1 << (nbits-1)

import ctypes

def hex2dec(v):
    return ctypes.c_int16(v).value

print hex2dec(0xfffc)
print hex2dec(0x0024)
print hex2dec(0xcafe)

hex(mem32[0xE000E400] & 0xffffffff)

The main problem is that int() cannot know how long the input is supposed to be; or in other words: it cannot know which bit is the MSB (most significant bit) designating the sign. In python, int just means "an integer, i.e. any whole number". There is no defined bit size of numbers, unlike in C.

For int(), the inputs 000000bd and bd therefore are the same; and the sign is determined by the presence or absence of a - prefix.

For arbitrary bit count of your input numbers (not only the standard 8, 16, 32, ...), you will need to do the two-complement conversion step manually, and tell it the supposed input size. (In C, you would do that implicitely by assigning the conversion result to an integer variable of the target bit size).

def hex_to_signed_number(s, width_in_bits):
    n = int(s, 16) & (pow(2, width_in_bits) - 1)
    if( n >= pow(2, width_in_bits-1) ):
        n -= pow(2, width_in_bits)
    return n

Some testcases for that function:

In [6]: hex_to_signed_number("bd", 8)
Out[6]: -67

In [7]: hex_to_signed_number("bd", 16)
Out[7]: 189

In [8]: hex_to_signed_number("80bd", 16)
Out[8]: -32579

In [9]: hex_to_signed_number("7fff", 16)
Out[9]: 32767

In [10]: hex_to_signed_number("8000", 16)
Out[10]: -32768