位运算，移动进位

问题描述：

struct.pack('!H', x)

但如果x大于65535那么这将很明显的原因而失败。
我不是一个具有位操作的向导，但我知道<<操作将会丢失任何移位的位。但我不知道如何从binary/bytes字符串中提取一个或多个携带位，并将携带值添加到尾随携带字节的两个字节集合中。

而且我需要每次遍历2个字节的字节串，并将它们与前两个字节相加。有时候这会产生一个大于65535的值 - 这是我需要从结果中提取进位的地方 - 并且用进位位本身对结果执行+操作（见下图）。

这就是我想要做到：（。在这种情况下，携带位只有一个，和2个尾随字节会得到+1结果）

而这就是我得赶紧至今：

from struct import unpack, pack 
from binascii import * 

even_bytes_string = b'\x45\x00\x00\x3c\x1c\x46\x40\x00\x40\x06\xac\x10\x0a\x63\x‌ac\x10\x0a\x0c' 
result = None 
for i in range(0, len(even_bytes_string)-1,2): 
    if not result: 
     result = unpack('!H', even_bytes_string[i:i+2])[0] 
     continue 

    result += unpack('!H', even_bytes_string[i:i+2])[0] 
    if result > 65535: 
     # Got a carry bit. 
     pass 

    print(result) 
    print(pack('!H', result))

我简直不知道如何做到这一点很简单的任务，而无需转换加法运算的结果转化为实际的二进制表示的字符串格式（11001...）。然后做字符串操作s = s[-16:]+s[:-16]（过于简化），最后将其转换回一组2个字节。它没有缝合实用，快速或非常“正确”。

我希望你们中的一位知道你在Python中的位操作的方式，可以告诉我这样做的正确方法是什么。必须有一些。

A的什么，我试图完成稍微混乱的画面（保持在结果2个字节，切掉任何传输位，并把它们添加到结果作为“独立”的价值。）：

你能指望什么，如果最后一位是1也不是0？ – Tryph

@Tryph我刚刚意识到我只是应该将这些携带位（可能是多个）添加到这两组字节中。所以我的问题需要更新。 – Torxed

也许我可以使用'carry = struct.pack（'！I'，result）[：2]'？再次，接缝类型不切实际，但会比转换为二进制表示和进行字符串操作更好！ – Torxed

答

该过程只是(x & 0xFFFF) + (x >> 16)。操作不需要涉及。这里有一个实施worked example你举：

def addwrap16(a, b): 
    c = a + b 
    w = (c & 0xFFFF) + (c >> 16) 
    print(' {:04x} -> {:016b}'.format(a, a)) 
    print(' {:04x} -> {:016b}'.format(b, b)) 
    print('{:05x} -> {:017b}'.format(c, c)) 
    print(' {:04x} -> {:016b}'.format(w, w)) 
    print('') 
    return w 

import struct, functools 
even_bytes_string = b'\x45\x00\x00\x3c\x1c\x46\x40\x00\x40\x06\xac\x10\x0a\x63\xac\x10\x0a\x0c' 
vals = struct.unpack('!' + 'H' * (len(even_bytes_string) // 2), even_bytes_string) 
result = functools.reduce(addwrap16, vals)

它吐出来的是以下几点：

4500 -> 0100010100000000 
003c -> 0000000000111100 
0453c -> 00100010100111100 
453c -> 0100010100111100 

453c -> 0100010100111100 
1c46 -> 0001110001000110 
06182 -> 00110000110000010 
6182 -> 0110000110000010 

6182 -> 0110000110000010 
4000 -> 0100000000000000 
0a182 -> 01010000110000010 
a182 -> 1010000110000010 

a182 -> 1010000110000010 
4006 -> 0100000000000110 
0e188 -> 01110000110001000 
e188 -> 1110000110001000 

e188 -> 1110000110001000 
ac10 -> 1010110000010000 
18d98 -> 11000110110011000 
8d99 -> 1000110110011001 

8d99 -> 1000110110011001 
0a63 -> 0000101001100011 
097fc -> 01001011111111100 
97fc -> 1001011111111100 

97fc -> 1001011111111100 
ac10 -> 1010110000010000 
1440c -> 10100010000001100 
440d -> 0100010000001101 

440d -> 0100010000001101 
0a0c -> 0000101000001100 
04e19 -> 00100111000011001 
4e19 -> 0100111000011001

'''只是一个偏移的例子，我希望能派上用场，但很快发现它没有。 “>>”或“|”操作都不会。这似乎是诀窍！ :) – Torxed

使用我的解决方案和你的手段，手动遵循我所期望的数值，他们都得出了相同的结论。在使用tcpdump的时候，它似乎是一个可用的网络校验和头文件，所以我对这个更高效的解决方案感到满意！非常感谢答案，我甚至看到了为什么这是工作的逻辑:) – Torxed

答

好所以这不是最优雅的解决方案，并且不确定它是否准确，但至少不会破坏struct.pack()。

基于由@Tryph一个简单的问题，这是我想出了一个变通办法：

from struct import unpack, pack 
from binascii import * 

even_bytes_string = b'\x45\x00\x00\x3c\x1c\x46\x40\x00\x40\x06\xac\x10\x0a\x63\x‌ac\x10\x0a\x0c' 
result = None 
for i in range(0, len(even_bytes_string)-1,2): 
    if not result: 
     result = unpack('!H', even_bytes_string[i:i+2])[0] 
     continue 

    result += unpack('!H', even_bytes_string[i:i+2])[0] 
    if result > 65535: 
     tmp = pack('!I', result) 
     carry = unpack('!H', tmp[:2])[0] 
     result = unpack('!H', tmp[2:])[0]+carry 

    print(result) 
    print(pack('!H', result))

简单地将更大数量的Int代替Short，这使我得到两个前置字节作为进位，并添加尾随两个字节的ontop。这不是优雅的，但可能有用？

位运算，移动进位

相关推荐