如何在Python中从24位整数中提取19-24位的比特值？

Got it, let's break this down step by step—bit extraction is all about clear numbering and using basic bitwise operations, so let's start with the basics to avoid confusion.

First, let's confirm your data details:

• You mentioned a byte array 01 00 00 which converts to integer 65536 (0x010000), but your binary string 0001 0000 0000 0000 0000 0000 actually matches the integer 1048576 (0x100000, byte array 10 00 00). I'll cover both cases, but focus on the binary you provided since that's the target for extraction.

Key Background: Bit Numbering #

First, clarify how we count bits:

• For your 24-bit binary string, we'll use 1-based numbering starting from the leftmost (most significant bit, MSB) as you implied. So:
  • Leftmost bit = Bit 24, rightmost = Bit 1
  • Your target range (Bits 19-24) is the first 6 bits of the binary: 000100

If we use 0-based numbering (standard in most programming languages, where Bit 0 is the rightmost least significant bit), this range translates to Bits 18-23.

Method 1: Using Integer Bitwise Operations #

This works if you've already converted the byte array to an integer. Here's the step-by-step process:

1. Define your values:

   # Using the integer matching your binary string (0x100000 = 1048576)
   num = 0x100000
   # Or convert directly from byte array (big-endian, since your first byte is MSB)
   num = int.from_bytes(b'\x10\x00\x00', byteorder='big')
   

2. Calculate the mask:
   We need a mask with 1s exactly in the bits we want to extract (Bits 18-23, 0-based):

   • Number of bits to extract: 6
   • Mask formula: ((1 << num_bits) - 1) << start_bit

   start_bit = 18  # 0-based start of the range
   num_bits = 6
   mask = ((1 << num_bits) - 1) << start_bit
   

3. Extract the bits:
   Use bitwise AND to isolate the target bits, then shift right to get a clean integer value:

   extracted_value = (num & mask) >> start_bit
   print(extracted_value)  # Output: 4 (matches binary 000100)
   

Method 2: Directly Working with the Byte Array #

If you don't want to convert the entire byte array to an integer, you can work directly with the relevant byte:

• Your target bits (19-24, 1-based) are the first 6 bits of the first byte (since it's big-endian).
• Shift the first byte right by 2 bits to drop the last 2 bits, leaving only the top 6:

  byte_array = b'\x10\x00\x00'
   first_byte = byte_array[0]
   extracted_value = first_byte >> 2
   print(extracted_value)  # Output: 4
  

What If Your Original Value Was 65536 (0x010000)? #

If you meant the byte array 01 00 00 (integer 65536), its 24-bit binary is 00000001 00000000 00000000. The only set bit is at position 16 (0-based), which is outside the 18-23 range. Using the same steps above would result in an extracted value of 0.

Key Takeaways #

• Always confirm bit numbering (MSB/LSB, 1-based/0-based) to avoid off-by-one errors.
• Use bitwise AND with a mask to isolate target bits, then shift right to get their integer value.
• For byte arrays, work directly with relevant bytes for more efficient processing.

内容的提问来源于stack exchange，提问作者VVK kumar