Python 为什么这个CRC不是一个2字节的字符串？

使用这个字符串“000016037000”和这个CRC16函数，结果不是一个2字节的字符串，为什么

def _crc16(data, bits=8):
    """private method: for calculating the CRC
    based on the standard EN50463-4

    Arguments:
        Input: data in ASCII encoding !
        Output: CRC of the data
    """
    crc = 0xFFFF
    for l in list(data):
        """or exclusive
        bin: gives the binary representation
        int: cast the string to an int with the base2
        ord: gives the ASCII code for the caracter between (0..255)
        """
        crc = crc ^ int(bin(ord(l)), 2)
        for bit in range(0, bits):
            if (crc & 0x0001) == 0x0001:
                crc = ((crc >> 1) ^ 0xA001)
            else:
                crc = crc >> 1

    return _typecasting(crc)


def _typecasting(crc):
    """gives the msb and lsb"""
    msb = hex(crc >> 8)
    lsb = hex(crc & 0x00FF)

    return lsb + msb

data = "000016037000"

print _crc16(data)

这是结果：0x00xfc，当您剥离“0x”时，它是0fc！CRC16应该生成2字节的校验和，lsb为0是否正常？

函数返回一个前面有

0x

的字符串。因此，在

类型转换

功能中，您有：

lsb = "0x00"
msb = "0xfc"

<>当你连接它们时，你在前面和中间都得到<代码> 0x<代码>。在连接之前，应该从

msb

中删除

0x

：

return lsb + msb[2:]

然后您将得到

0x00fc

hex（）

函数返回一个前面有

0x

的字符串。因此，在

类型转换

功能中，您有：

lsb = "0x00"
msb = "0xfc"

<>当你连接它们时，你在前面和中间都得到<代码> 0x<代码>。在连接之前，应该从

msb

中删除

0x

：

return lsb + msb[2:]

然后您将得到

0x00fc

hex（）

函数返回一个前面有

0x

的字符串。因此，在

类型转换

功能中，您有：

lsb = "0x00"
msb = "0xfc"

<>当你连接它们时，你在前面和中间都得到<代码> 0x<代码>。在连接之前，应该从

msb

中删除

0x

：

return lsb + msb[2:]

然后您将得到

0x00fc

hex（）

函数返回一个前面有

0x

的字符串。因此，在

类型转换

功能中，您有：

lsb = "0x00"
msb = "0xfc"

<>当你连接它们时，你在前面和中间都得到<代码> 0x<代码>。在连接之前，应该从

msb

中删除

0x

：

return lsb + msb[2:]

---

然后您将得到

0x00fc

是的，这是正常的。这就像

10

中的

0

。顺便说一句，你的主循环有点太冗长了，那么：

crc = 0xFFFF
for l in data:
    crc ^= ord(l)
    for bit in range(0, bits):
        if crc & 1:
            crc = (crc >> 1) ^ 0xA001
        else:
            crc >>= 1

typecasting

函数似乎是交换lsb和msb的，可以更简洁地编写为

def byteswap(crc):    
    return (crc >> 8) | (crc & 0x00FF) << 8

def byteswap（crc）：
返回（crc>>8）|（crc&0x00FF）是的，这是正常的。这就像
10
中的
0
。顺便说一句，你的主循环有点太冗长了，那么：

crc = 0xFFFF
for l in data:
    crc ^= ord(l)
    for bit in range(0, bits):
        if crc & 1:
            crc = (crc >> 1) ^ 0xA001
        else:
            crc >>= 1

typecasting
函数似乎是交换lsb和msb的，可以更简洁地编写为

def byteswap(crc):    
    return (crc >> 8) | (crc & 0x00FF) << 8

def byteswap（crc）：
返回（crc>>8）|（crc&0x00FF）是的，这是正常的。这就像
10
中的
0
。顺便说一句，你的主循环有点太冗长了，那么：

crc = 0xFFFF
for l in data:
    crc ^= ord(l)
    for bit in range(0, bits):
        if crc & 1:
            crc = (crc >> 1) ^ 0xA001
        else:
            crc >>= 1

typecasting
函数似乎是交换lsb和msb的，可以更简洁地编写为

def byteswap(crc):    
    return (crc >> 8) | (crc & 0x00FF) << 8

def byteswap（crc）：
返回（crc>>8）|（crc&0x00FF）是的，这是正常的。这就像
10
中的
0
。顺便说一句，你的主循环有点太冗长了，那么：

crc = 0xFFFF
for l in data:
    crc ^= ord(l)
    for bit in range(0, bits):
        if crc & 1:
            crc = (crc >> 1) ^ 0xA001
        else:
            crc >>= 1

typecasting
函数似乎是交换lsb和msb的，可以更简洁地编写为

def byteswap(crc):    
    return (crc >> 8) | (crc & 0x00FF) << 8

def byteswap（crc）：
return（crc>>8）|（crc&0x00FF）您似乎有很多不必要的转换，问题是关于其中一种效果。我会试着按执行顺序解释

for l in list(data):

这里将字符串转换为字母列表，每个字母本身就是一个字符串（Python不使用char数据类型）。这样做之所以有效，是因为可以对字符串本身进行迭代；只需删除list（）调用

作为旁注，ord（）实际上得到了序数；它不一定是ASCII码（事实上，没有>127的代码是ASCII码）。一旦我们有了这个数字，你就把它转换成一个二进制的文本表示形式；配对后，两个转换都是冗余的

msb = hex(crc >> 8)
lsb = hex(crc & 0x00FF)
return lsb + msb

每次调用hex（）都会转换为十六进制表示形式。与bin（）一样，这是Python数值文本的形式，因此它们的前缀都是0x。将它们连接起来会产生一种有点奇怪的格式（尽管仍然可以恢复，但它与任何常见的格式都不相似）。在这一点上，知道你的目标可能会很好

一种猜测是，您需要一个4位十六进制格式的小尾数16位无符号整数（面向字节的十六进制转储）。我们可以使用Python的标准库来表示：

import binascii, struct
le16hex = binascii.b2a_hex(struct.pack('<H', crc))

导入binascii，结构
le16hex=binascii.b2a_hex（struct.pack（“您似乎有很多不必要的转换，问题是关于其中一个效果。我将尝试按执行顺序解释它们

for l in list(data):

在这里，您可以将一个字符串转换为一个字母列表，每个字母本身都是一个字符串（Python不使用char数据类型）

作为旁注，ord（）实际上为我们提供了序号；它不一定是ASCII码（事实上，没有任何大于127的代码是ASCII码）。一旦我们有了这个数字，您就将它转换为二进制文本表示形式，然后再转换回来；配对后，两种转换都是多余的

msb = hex(crc >> 8)
lsb = hex(crc & 0x00FF)
return lsb + msb

对hex（）的每次调用都会转换为十六进制表示形式。与bin（）一样，这是Python数值文本的形式，因此它们的前缀都是0x。将它们连接在一起会产生一种有点奇怪的格式（尽管仍然可以恢复，但与任何常见格式都不相似）.在这一点上，知道你的目标可能会很好

一种猜测是，您需要一个4位十六进制格式（面向字节的hextump）的小尾数16位无符号整数。我们可以使用Python的标准库来表示：

import binascii, struct
le16hex = binascii.b2a_hex(struct.pack('<H', crc))

导入binascii，结构
le16hex=binascii.b2a_hex（struct.pack（“您似乎有很多不必要的转换，问题是关于其中一个效果。我将尝试按执行顺序解释它们

for l in list(data):

在这里，您可以将一个字符串转换为一个字母列表，每个字母本身都是一个字符串（Python不使用char数据类型）

作为旁注，ord（）实际上为我们提供了