import struct
import binascii
class Converter(object):
"""
* * * 针对十六进制:length指的是期待生成的字符长度(半个字节),比如length为4,就是两个字节0x1234 * * *
int_list = Converter.hexstr_to_intlist(hex_str) # 十六进制字符串 → 整数(ASCII码)列表
chars = Converter.intlist_to_chars(int_list) # 整数(ASCII码)列表 → char字符串
chars = Converter.hexstr_to_chars(hex_str) # 十六进制字符串 → char字符串
int_list = Converter.chars_to_intlist(chars) # char字符串 → 整数(ASCII码)列表
hex_str = Converter.intlist_to_hexstr(int_list) # 整数(ASCII码)列表 → 十六进制字符串
hex_str = Converter.chars_to_hexstr(chars) # char字符串 → 十六进制字符串
"""
@staticmethod
def hexstr_to_intlist(hex_str):
"""十六进制字符串 → 整数(ASCII码)列表"""
int_list = [int(hex_str[i:i + 2], 16) for i in range(0, len(hex_str), 2)]
return int_list
@staticmethod
def intlist_to_chars(int_list):
"""整数(ASCII码)列表 → char字符串"""
char_list = [chr(x) for x in int_list]
chars = ''.join(char_list)
return chars
@staticmethod
def hexstr_to_chars(hex_str):
"""十六进制字符串 → char字符串"""
char_list = [chr(int(hex_str[i:i + 2], 16)) for i in range(0, len(hex_str), 2)]
chars = ''.join(char_list)
return chars
@staticmethod
def chars_to_intlist(chars):
"""char字符串 → 整数(ASCII码)列表"""
int_list = [ord(x) for x in chars]
return int_list
# @staticmethod
# def intlist_to_hexstr(int_list):
# """整数(ASCII码)列表 → 十六进制字符串"""
#
# hex_str_list = ["{:02X}".format(x) for x in int_list]
# hex_str = ''.join(hex_str_list)
# return hex_str
@staticmethod
def chars_to_hexstr(chars):
"""char字符串 → 十六进制字符串"""
hex_str_list = ["{:02X}".format(ord(x)) for x in chars]
hex_str = ''.join(hex_str_list)
return hex_str
# @staticmethod
# def to_hex(s):
# list_h = []
# for c in s:
# list_h.append(str(hex(ord(c))[2:]))
# return ''.join(list_h)
class ConverterEx(Converter):
@staticmethod
def hexstr_to_intlist(hex_str):
"""十六进制字符串 → 整数(ASCII码)列表
【每2个十六进制字符串转为一个int值】"""
int_list = [int(hex_str[i:i + 2], 16) for i in range(0, len(hex_str), 2)]
return int_list
@staticmethod
def intlist_to_chars(int_list):
"""整数(ASCII码)列表 → char字符串"""
char_list = [chr(x) for x in int_list]
chars = ''.join(char_list)
return chars
@staticmethod
def hexstr_to_chars(hex_str):
"""十六进制字符串 → char字符串
【每2个十六进制字符串转为一个int值,int值找到对应的ASCII字符】"""
char_list = [chr(int(hex_str[i:i + 2], 16)) for i in range(0, len(hex_str), 2)]
chars = ''.join(char_list)
return chars
@staticmethod
def chars_to_intlist(chars):
"""char字符串 → 整数(ASCII码)列表"""
int_list = [ord(x) for x in chars]
return int_list
@staticmethod
def intlist_to_hexstr(int_list, length=2):
"""整数(ASCII码)列表 → 十六进制字符串
【每个整数转化为length个字符的十六进制字符串,前面补0】【2个字符就是一个字节,所以不需要考虑高位、低位的问题;如果不是2个字符就不行】
兼容负数
"""
# hex_str_list = ["{:02X}".format(x) for x in int_list]
hex_str_list = [f"{x:0{length}X}" if x >= 0 else hex(2 ** (length*4) + x)[2:] for x in int_list] # 兼容负数
hex_str = ''.join(hex_str_list)
return hex_str
@staticmethod
def chars_to_hexstr(chars, length=2):
"""char字符串 → 十六进制字符串
【每个字符的ord转化为length个字符的十六进制字符串,前面补0】"""
# hex_str_list = ["{:02X}".format(ord(x)) for x in chars]
hex_str_list = [f"{ord(x):0{length}X}" for x in chars]
hex_str = ''.join(hex_str_list)
return hex_str
@staticmethod
def hexstr_2_intlist(hexstr):
"""
这个函数式之前的hexstr_2_hexstrlist,突然发现其实是int_list才对
十六进制形式的字符串,每两个转为数字,最终串成一个列表【真正使用的时候还会根据需要再逆转一下】
例如:'ff0f'转为[255, 15]"""
return Converter.hexstr_to_intlist(hexstr)
@staticmethod
def hexstr_2_intlist_reversed(hexstr):
"""
这个函数式之前的hexstr_2_hexstrlist,突然发现其实是int_list才对
十六进制形式的字符串,每两个转为数字,最终串成一个列表【真正使用的时候还会根据需要再逆转一下】
例如:'ff0f'转为[15, 255]"""
intlist = ConverterEx.hexstr_2_intlist(hexstr)
intlist.reverse()
return intlist
@staticmethod
def hexstr_2_hexstrlist(hexstr):
"""十六进制形式的字符串,每两个作为一个短字符串,最终串成一个列表【真正使用的时候还会根据需要再逆转一下】
例如:'ffff'转为["ff", "ff"]"""
return [hexstr[i:i + 2] for i in range(0, len(hexstr), 2)]
@staticmethod
def hexstr_2_hexstrlist_reversed(hexstr):
"""十六进制形式的字符串,每两个作为一个短字符串,最终串成一个列表【并且逆转一下】
例如:'fff1'转为["f1", "ff"]"""
byte_list = ConverterEx.hexstr_2_hexstrlist(hexstr)
byte_list.reverse()
return byte_list
@staticmethod
def hexstr_to_int(hex_str):
"""十六进制字符串 → 整数(ASCII码)"""
int_value = int(hex_str, 16)
return int_value
@staticmethod
def int_to_hexstr(int_value, length=8):
"""整数(ASCII码) → 指定长度的十六进制字符串
更新了一下,兼容负数的情况
"""
if int_value < 0:
hex_str = hex(2 ** (length*4) + int_value)[2:] # 负数
else:
hex_str = f"{int_value:0{length}X}"
return hex_str
@staticmethod
def int_to_binarystr(int_value, length=8):
"""整数(ASCII码) → 指定长度的十六进制字符串"""
binary_str = f"{int_value:0{length}b}"
return binary_str
@staticmethod
def binarystr_to_hexstr(binary_str, length=8):
"""二进制字符串 → 指定长度的十六进制字符串"""
int_value = int(binary_str, 2)
hex_str = ConverterEx.int_to_hexstr(int_value=int_value, length=length)
return hex_str
@staticmethod
def float_to_hexstr(number=6.0):
"""这个已经逆序过了"""
# number = 238.3
float_number = struct.pack("<f", number)
# print(float_number) # b'\x00\x00\x80?'
# print(binascii.b2a_hex(float_number)) # b'0000803f'
hex_str = binascii.b2a_hex(float_number).decode() # 0000803f:str
# print(type(hex_str)) # <class 'str'>
# print(hex_str) # 0000803f
return hex_str
def double_to_hexstr(number=6.0):
"""这个已经逆序过了"""
# number = 6.0
float_number = struct.pack("<d", number)
# print(float_number) # b'\x00\x00\x00\x00\x00\x00\x18@'
# print(binascii.b2a_hex(float_number)) # b'0000000000001840'/
hex_str = binascii.b2a_hex(float_number).decode()
# print(type(hex_str)) # <class 'str'>
# print(hex_str) # 0000000000001840
return hex_str
@staticmethod
def hexstr_to_float(hex_str="40c00000"):
float_number = struct.unpack('!f', binascii.a2b_hex(hex_str))[0]
# print(float_number)
return float_number
@staticmethod
def hexstr_to_double(hex_str="4018000000000000"):
float_number = struct.unpack('!d', binascii.a2b_hex(hex_str))[0]
# print(float_number)
return float_number
@staticmethod
def hexstr_reverse(hex_str="0000c040"):
int_list = Converter.hexstr_to_intlist(hex_str)
int_list.reverse()
hex_str_reverse = ConverterEx.intlist_to_hexstr(int_list, length=2) # 40c00000
return hex_str_reverse
@staticmethod
def int_to_hexstr_reverse(int_value, length):
"""整数(ASCII码) → 指定长度的十六进制字符串(并且按字节逆序)
输入(320, 4),输出4001【0x0140】
"""
hex_str = ConverterEx.int_to_hexstr(int_value, length)
hex_str = ConverterEx.hexstr_reverse(hex_str)
return hex_str
@staticmethod
def int_to_command_str(value_int):
"""只能4位:{:08X}
例如:255转为“FF000000” """
if value_int < 0:
hexstr_gain = hex(2 ** 32 + value_int)[2:] # -512就是"FFFFFE00"
else:
hexstr_gain = "{:08X}".format(value_int) # 数字(整数,不管是2进制还是,8/10/16进制)转字符串(16进制的而且是8位长度)
additional_byte_list = ConverterEx.hexstr_2_hexstrlist(hexstr_gain) # 字符串每两个字符(一个字节)转为一个列表元素
additional_byte_list.reverse() # 逆序【列表元素逆序】
command_str = "".join(additional_byte_list) # 拼接起来就是发送的增益值的16进制对应的字符串(按字节逆序)
# 或者用:
# additional_byte_list = Converter.hexstr_2_intlist(hexstr_gain) # 字符串每两个字符(一个字节)转为一个列表元素
# additional_byte_list.reverse() # 逆序【列表元素逆序】
# command_str = "".join(["{:02X}".format(x) for x in additional_byte_list]) # 拼接起来就是发送的增益值的16进制对应的字符串(按字节逆序)
return command_str
@staticmethod
def command_str_to_int(command_str):
"""只能4位:{:08X}
例如:255转为“FF000000” """
additional_byte_list = ConverterEx.hexstr_2_hexstrlist(command_str)
additional_byte_list.reverse() # 逆序【列表元素逆序】
command_str = "".join(additional_byte_list) # 拼接起来就是发送的增益值的16进制对应的字符串(按字节逆序)
if command_str[0] in "ABCDEFabcdef":
value_int = -2 ** 32 + int(command_str, 16) # -512就是"FFFFFE00"
else:
value_int = int(command_str, 16) # 数字(整数,不管是2进制还是,8/10/16进制)转字符串(16进制的而且是8位长度)
return value_int
def main():
converter_ex_obj = ConverterEx()
# hex_str = converter_ex_obj.int_to_hexstr_reverse(320, 4)
# print(f"hex_str: {hex_str}")
# hex_str = converter_ex_obj.int_to_hexstr(12, 4)
# print(f"hex_str: {hex_str}")
hex_str = converter_ex_obj.intlist_to_hexstr([12, -12], 2)
print(f"hex_str: {hex_str}")
# value_int = -2
# command_str = converter_ex_obj.int_to_command_str(value_int)
# print(f"command_str: {command_str}")
if __name__ == '__main__':
main()
python:各种形式字符和数字的相互转换:字符型,数字型,浮点型,十六进制,十进制,二进制。。。
于 2022-09-08 09:31:23 首次发布