¿Cómo leer bits de un archivo?

Question

Sé leer bytes - x.read(number_of_bytes), pero ¿cómo puedo leer bits en Python?

tengo que leer sólo 5 bits (8 bits no [1 byte]) a partir de un archivo binario

Cualquier idea o enfoque?

Answer 1

Python solo puede leer un byte a la vez. Debería leer en un byte completo, luego simplemente extraer el valor que desea de ese byte, p.

b = x.read(1) 
firstfivebits = b >> 3 

O si quería los 5 bits menos significativos, en lugar de los 5 bits más significativos:

b = x.read(1) 
lastfivebits = b & 0b11111 

Algunos otra información útil de manipulación de bits se puede encontrar aquí: http://wiki.python.org/moin/BitManipulation

Answer 2

A medida que la estados de respuesta aceptados, la E/S Python estándar solo puede leer y escribir bytes enteros a la vez. Sin embargo, puede simular tal flujo de bits usando esta receta para Bitwise I/O.

Actualización:

Desde el sitio web del Código de Rosetta GNU license permite la copia literal, aquí está la versión Python del flujo de bits de E/S en su totalidad:

Actualización 2:

Después de modificar la versión Python del código Rosetta para que funcione sin cambios en Python 2 & 3, he incorporado los cambios en esta respuesta.

class BitWriter(object): 
    def __init__(self, f): 
     self.accumulator = 0 
     self.bcount = 0 
     self.out = f 

    def __del__(self): 
     try: 
      self.flush() 
     except ValueError: # I/O operation on closed file 
      pass 

    def _writebit(self, bit): 
     if self.bcount == 8: 
      self.flush() 
     if bit > 0: 
      self.accumulator |= 1 << 7-self.bcount 
     self.bcount += 1 

    def writebits(self, bits, n): 
     while n > 0: 
      self._writebit(bits & 1 << n-1) 
      n -= 1 

    def flush(self): 
     self.out.write(bytearray([self.accumulator])) 
     self.accumulator = 0 
     self.bcount = 0 


class BitReader(object): 
    def __init__(self, f): 
     self.input = f 
     self.accumulator = 0 
     self.bcount = 0 
     self.read = 0 

    def _readbit(self): 
     if not self.bcount: 
      a = self.input.read(1) 
      if a: 
       self.accumulator = ord(a) 
      self.bcount = 8 
      self.read = len(a) 
     rv = (self.accumulator & (1 << self.bcount-1)) >> self.bcount-1 
     self.bcount -= 1 
     return rv 

    def readbits(self, n): 
     v = 0 
     while n > 0: 
      v = (v << 1) | self._readbit() 
      n -= 1 
     return v 

if __name__ == '__main__': 
    import os 
    import sys 
    # determine module name from this file's name and import it 
    module_name = os.path.splitext(os.path.basename(__file__))[0] 
    bitio = __import__(module_name) 

    with open('bitio_test.dat', 'wb') as outfile: 
     writer = bitio.BitWriter(outfile) 
     chars = '12345abcde' 
     for ch in chars: 
      writer.writebits(ord(ch), 7) 

    with open('bitio_test.dat', 'rb') as infile: 
     reader = bitio.BitReader(infile) 
     chars = [] 
     while True: 
      x = reader.readbits(7) 
      if reader.read == 0: 
       break 
      chars.append(chr(x)) 
     print(''.join(chars)) 

Otro ejemplo que muestra cómo el uso de "crisis", un flujo de bytes ASCII de 8 bits descartando el bit más significativo "sin usar" ... y leer de nuevo.

import sys 
import bitio 

o = bitio.BitWriter(sys.stdout) 
c = sys.stdin.read(1) 
while len(c) > 0: 
    o.writebits(ord(c), 7) 
    c = sys.stdin.read(1) 

... y para "decrunch" la misma corriente:

import sys 
import bitio 

r = bitio.BitReader(sys.stdin) 
while True: 
    x = r.readbits(7) 
    if not r.read: # nothing read 
     break 
    sys.stdout.write(chr(x))