Chaîne hexadécimale à signé int en Python 3.2?

Comment puis-je convertir une chaîne hexadécimale de la signature d'un int en Python 3.2?

Du mieux que je peux venir avec est

h = '9DA92DAB'
b = bytes(h, 'utf-8')
ba = binascii.a2b_hex(b)
print(int.from_bytes(ba, byteorder='big', signed=True))

Est-il un moyen plus simple? Non signé est tellement plus facile: int(h, 16)

BTW, l'origine de la question est itunes identifiant persistant - la musique de la bibliothèque xml version et iTunes hex version

Les deux lignes b= et ba= peut être remplacé par ba=octets.fromhex(h). Voir Lennart commentaire ci-dessous.

OriginalL'auteur foosion | 2011-07-18

22
```
x = int(h,16)
if x > 0x7FFFFFFF:
    x -= 0x100000000
```
Je crois que la clause if x = -x à la fin
Bon, je déteste taper le code sur un iPad. Peut pas être exécuté pour vérifier.
Gardant cela à l'esprit sans l'exécuter (ou d'avoir de meilleurs google compétences que je n') est bonne

OriginalL'auteur Mark Tolonen
4
```
import struct
```
Pour Python 3 (avec les commentaires de l'aide):
```
h = '9DA92DAB'
struct.unpack('>i', bytes.fromhex(h))
```
Pour Python 2:
```
h = '9DA92DAB'
struct.unpack('>i', h.decode('hex'))
```
ou si elle est en little endian:
```
h = '9DA92DAB'
struct.unpack('<i', h.decode('hex'))
```
Fonctionne en python 2.7, mais pas 3.2: AttributeError: 'str' object n'a pas d'attribut "décoder"
N'ont pas de Python 3 pour tester cela, mais en se fondant sur la documentation struct.unpack('>i', bytes('9DA92DAB', 'utf-8')) devrait fonctionner.
Il n'a pas. h.decode('hex') et d'octets(h, 'utf8') faire des choses complètement différentes. Vous souhaitez octets.fromhex(h).
Mon mauvais. Signifiait struct.unpack('>i', bytes('9DA92DAB', 'utf-8').decode('hex')). Mais ça devient ridiculement longue de toute façon, et la demande a été pour quelque chose de plus simple. Et c'est aussi ne pas sur Python 3... Meh pour enlever les 'hex'.
En utilisant des encodages Unicode pour l'encodage hexadécimal est illogique et sujettes à la rupture.

OriginalL'auteur kichik

Voici une fonction que vous pouvez utiliser pour hex de toute taille:

import math

# hex string to signed integer
def htosi(val):
    uintval = int(val,16)
    bits = 4 * (len(val) - 2)
    if uintval >= math.pow(2,bits-1):
        uintval = int(0 - (math.pow(2,bits) - uintval))
    return uintval

Et de l'utiliser:

h = str(hex(-5))
h2 = str(hex(-13589))
x = htosi(h)
x2 = htosi(h2)

OriginalL'auteur justsomedude

C'est un très tardive réponse, mais voici une fonction pour faire la-dessus. Cela permet de prolonger pour n'importe quelle longueur que vous fournissez. De crédit pour des parties de cet autre, de SORTE de réponse (j'ai perdu le lien, donc merci de nous la fournir si vous le trouvez).

def hex_to_signed(source):
    """Convert a string hex value to a signed hexidecimal value.

    This assumes that source is the proper length, and the sign bit
    is the first bit in the first byte of the correct length.

    hex_to_signed("F") should return -1.
    hex_to_signed("0F") should return 15.
    """
    if not isinstance(source, str):
        raise ValueError("string type required")
    if 0 == len(source):
        raise valueError("string is empty")
    sign_bit_mask = 1 << (len(source)*4-1)
    other_bits_mask = sign_bit_mask - 1
    value = int(source, 16)
    return -(value & sign_bit_mask) | (value & other_bits_mask)

OriginalL'auteur Joe Marley

0

Cela fonctionne pour les 16 bits signé ints, vous pouvez étendre de 32 bits entiers. Il utilise la définition de base de 2 en complément des nombres signés. noter Également xor avec 1 est la même chose qu'un binaire nier.
```
# convert to unsigned
x = int('ffbf', 16) # example (-65)
# check sign bit
if (x & 0x8000) == 0x8000:
    # if set, invert and add one to get the negative value, then add the negative sign
    x = -( (x ^ 0xffff) + 1)
```
OriginalL'auteur amarchiori

Vous devez vous connecter pour publier un commentaire.