Comment puis-je convertir une partie d'un python tuple (tableau d'octets) en un entier

Je suis en train de parler à un périphérique à l'aide de python. J'ai reçu un n-uplet d'octets qui contient les informations de stockage. Comment puis-je convertir les données dans les valeurs correctes:

réponse = (0, 0, 117, 143, 6)

Les 4 premières valeurs sont en 32 bits int de me dire combien d'octets ont été utilisés et la dernière valeur est le pourcentage utilisé.

Je peux accéder à la tuple comme réponse[0], mais ne peut pas voir comment je peux obtenir les 4 premières valeurs dans l'int qu'il me faut.

InformationsquelleAutor Phil Hannent | 2008-12-22

python tuples

11

Voir Convertir des Octets pour les Nombres à virgule Flottante en Python

Vous voudrez probablement utiliser la structure de module, par exemple
```
import struct

response = (0, 0, 117, 143, 6)
struct.unpack(">I", ''.join([chr(x) for x in response[:-1]]))
```
En supposant un unsigned int. Il peut y avoir une meilleure façon de faire la conversion pour décompresser, une compréhension de liste avec une jointure était juste la première chose que j'ai trouvé.

MODIFIER: Voir aussi ΤΖΩΤΖΙΟΥ commentaire de cette réponse concernant l'endianness ainsi.

EDIT #2: Si vous n'avez pas l'esprit à l'aide de la matrice de module ainsi, voici une autre méthode qui élimine la nécessité d'une compréhension de liste. Grâce à @JimB pour préciser que déballer peut fonctionner sur des tableaux en tant que bien.
```
import struct
from array import array

response = (0, 0, 117, 143, 6)
bytes = array('B', response[:-1])
struct.unpack('>I', bytes)
```
- Je voudrais suggérer que le pack format ">I" c'est à dire big endian; 0x0000758f (30095₁₀) de façon aléatoire un nombre d'octets semble plus probable que 0x8f750000 (2406809600₁₀)
InformationsquelleAutor Jay
13

Serait,

num = (réponse[0] << 24) +
(réponse[1] << 16) + (réponse[2] <<
8) + réponse[3]

répondre à vos besoins?

aide
- lors de la lecture des réponses ci-dessus, avec l'importation de modules, à l'aide de boucles et des compréhensions pour quelque chose d'aussi trivial que cela, j'ai vraiment commencé à me gratter la tête... cette réponse est en fait la façon dont il est (et devraient) être fait n'importe où, et rien ne pourra battre ce en termes de rapidité et de simplicité...
- Un moyen facile de le faire
InformationsquelleAutor
4

OK, Vous n'indiquez pas le endinanness ou si l'entier est signé ou et (peut-être) est plus rapide avec la struct module:
```
b = (8, 1, 0, 0)
sum(b[i] << (i * 8) for i in range(4))
```
- juste pour la référence c'est pour little-endian et peut éventuellement être légèrement améliorée 'sum(b[i] << i * 8) for i in range(len(b)))' pour permettre de taille variable d'entrée ou de " somme(réponse[i] << i * 8) for i in range(len(réponse)-1))' pour l'OP.
- J'aime bien cette solution, car il est probablement plus rapide que de struct.déballer et à la différence de la méthode, il ne nécessite pas l'importation d'un module. Pourriez-vous fournir une version qui permettrait de gérer big-endian mais s'il vous plaît?
InformationsquelleAutor
4

Vous pouvez également faire usage de la matrice de module
```
import struct
from array import array
response = (0, 0, 117, 143, 6)
a = array('B', response[:4])
struct.unpack('>I', a)

(30095L,)
```
- J'ai essayé cette approche trop, mais a décidé d'aller avec une compréhension de liste et join() au lieu de cela, pour éviter d'importer un autre module, et depuis ne l'était pas particulièrement clair, malheureusement.
- J'ai oublié cette structure peut pack tableaux [résolu réponse], qui, je pense, rend cette version est légèrement mieux que la liste comp.
- Sympa, je ne savais pas qu'il pouvait le faire, oubliée dans les docs. Je vais l'ajouter à ma réponse comme une autre.
InformationsquelleAutor JimB
2

Cela ressemble à un travail pour réduire les!

Ce que vous avez besoin est à, décalage de bit d'un octet à la fois, puis ajouter (plus) de l'octet suivant dans la séquence.
```
a = (0, 0, 117, 143, 6)
reduce(lambda x, y: (x<<8) + y, a)
7704326
```
- -1 Lire la question. Il y a CINQ octets. L'OP dit les 4 premiers sont en 32 bits int. Le dernier est un pourcentage (6%).
- Je pense que c'est juste une petite erreur, il suffit de changer dans la deuxième ligne a à a[:4] et le code fonctionne comme il faut par les OP (au moins si big endian) est envisagée. Pas besoin de downvote directement.
- toute chance d'une version de ce pour little endian s'il vous plaît?
- en tenant compte de Jean de commentaire: reduce(lambda x, y: (x<<8) + y, un[:4][::-1])
InformationsquelleAutor Kristian Vinther
0

Comment sur l'utilisation de la carte fonction:
```
a = (0, 0, 117, 143, 6)
b = []
map(b.append, a)
```
Aussi, je ne sais pas si c'est que vous êtes à la recherche pour:
```
response = (0, 0, 117, 143, 6)
response[0:4]
```
InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.