python：各种形式字符和数字的相互转换：字符型，数字型，浮点型，十六进制，十进制，二进制。。。

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