Jak odczytywać bity z pliku?

Question

Wiem, jak czytać bajty - x.read(number_of_bytes), ale jak mogę czytać bity w Pythonie?

muszę czytać tylko 5 bitów (8 bitów nie [1 bajt]) z pliku binarnego

Wszelkie pomysły i podejście?

Answer 1

Python może czytać tylko bajt na raz. Musisz przeczytać pełny bajt, a następnie wypakować żądaną wartość z tego bajtu, np.

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

Lub jeśli chciał, 5 najmniej znaczące bity, a nie 5 najbardziej znaczących bitów:

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

Niektóre inne przydatne informacje nieco manipulacji można znaleźć tutaj: http://wiki.python.org/moin/BitManipulation

Answer 2

Jak akceptowane stany odpowiedzi, standardowe Python I/O może tylko czytać i zapisywać cały bajt (y) na raz. Można jednak symulować taki strumień bitów za pomocą tego przepisu dla Bitwise I/O.

Aktualizacja:

Ponieważ strona Kod Rosetty GNU license pozwala verbatim kopiowanie, tu jest wersja Pythona od strumienia bitów I/O w całości:

Aktualizacja 2:

Po zmodyfikowaniu wersji Pythona kodu Rosetta do pracy w niezmienionej wersji w Pythonie 2 & 3, uwzględniłem zmiany w tej odpowiedzi.

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)) 

Innym przykładem użycia pokazujący jak „kryzys” 8-bitowy bajt ASCII strumień odrzucając najbardziej znaczący „nieużywany” kawałek ... i odczytać go z powrotem.

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) 

... i "decrunch" tego samego strumienia:

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))