Quelle est la manière correcte de traiter 4 bits dans un octet en python?

Question

J'écris une application pour analyser certains paquets réseau. Un champ de paquet contient le numéro de version du protocole dans un octet, de sorte que 4 bits hauts sont les «majeurs» et les 4 faibles sont la version «mineure». Actuellement, je les analyse comme suit, mais me demande s'il y a une façon de faire plus jolie ou plus « pythonique » il:

v = ord(data[17]) 
    major = (v & int('11110000',2)) >> 4 
    minor = v & int('00001111',2) 

Answer 1

Vous pouvez écrire littéraux binaires comme celui-ci 0b1111000

Pour votre exemple, je voudrais proabbly utiliser hex si

v = ord(data[17]) 
major = (v & 0xF0) >> 4 
minor = (v & 0x0F) 

Vous pouvez également utiliser le module struct pour briser le paquet dans ses composants

Answer 2

Il serait plus facile d'utiliser des littéraux au lieu d'appeler int. Vous pouvez utiliser les littéraux binaires ou hexagonal, par exemple:

major = (v & 0xf0) >> 4 
minor = (v & 0x0f) 

littéraux binaires ne fonctionnent que pour Python 2.6 ou version ultérieure et sont de la forme 0b11110000. Si vous utilisez Python 2.6 ou version ultérieure, vous voudrez peut-être regarder le type bytearray car cela vous permettra de traiter les données comme binaires et de ne pas avoir à utiliser l'appel à ord.

Si vous analysez des données binaires et constatez que vous devez effectuer de nombreuses manipulations de bits, vous pouvez essayer une solution plus générale car certains modules tiers sont spécialisés dans ce domaine. L'un est hachoir, et une alternative de niveau inférieur est bitstring (que j'ai écrit). Dans ce votre analyse deviendrait quelque chose comme:

major, minor = data.readlist('uint:4, uint:4') 

qui peut être plus facile à gérer si vous faites beaucoup de ces lectures.

Answer 3

Juste un soupçon, vous feriez mieux d'appliquer le masque pour le majeur après déplacement, dans le cas où il est un nombre négatif et le signe est maintenu:

major = (v >> 4) & 0x0f 
minor = (v & 0x0f) 

Answer 4

fonctions bien nommées sont toujours une bonne façon pour cacher la laideur et la complexité non pertinente. De cette façon, le jeu de bits est confiné à de petites fonctions correctes et facilement éprouvées tandis que le code de niveau supérieur peut se référer à l'objectif du violon.

def high_nibble(byte): 
    """Get 4 high order bits from a byte.""" 
    return (byte >> 4) & 0xF 

def low_nibble(byte): 
    """Get 4 low order bits from a byte.""" 
    return byte & 0xF 

def parse_version(version_byte): 
    """Get the major-minor version tuple from the version byte.""" 
    return high_nibble(version_byte), low_nibble(version_byte) 

major, minor = parse_version(version_byte)