Python中int、str、bytes相互转化，还有2进制、16进制表示，你想要的都在这里了

前言

数据类型转换是个很基础的操作，很多语言中都要做这些转换，例如前一段时间刚刚总结了《C/C++中string和int相互转换的常用方法》，python 自从分离出 python3 版本之后，str 和 bytes 两个类型弄蒙了一大票人，在这两种类型的转换上我可是花了不少时间，记住一点，别随随便便使用 str() 函数，很多数据使用 str() 变成字符串之后再想恢复可就难了。

本文所有示例均在 Python 3.7.5 上测试，Python2 已经被我抛弃了，我来试着把常见的转换都放到一起，把踩过的坑拿来开心一下，如果有些常用的类型转换这里没有的话，也欢迎小伙伴们提出来，我将持续补充，好了，可以开始了。

数据类型转化

数字中除了整数，还有浮点数、复数等，但是 int 是最常见的类型，所有转换中的数字只涉及 int 数字类型。

int -> str

使用 str() 函数

num = 10
val = str(10)
print(type(val), val)

# 10

使用 format() 函数

num = 10
val = '{0}'.format(num)
print(type(val), val)

# 10

使用 hex() 转换成16进制形式

num = 10
val = hex(num)
print(type(val), val)

# 0xa

使用 bin() 转换成2进制形式

num = 10
val = bin(num).replace('0b','')
print(type(val), val)

# 1010

str -> int

这个转换比较专一，只使用 int() 函数就可以了，这个函数实际上有两个参数，第二个参数表示进制，默认是10进制，你可以改成2进制或者16进制，甚至是3进制、5进制等等

使用 int() 进行各进制数字转换

val = int('10')
print(type(val), val)

val = int('0xa', 16)
print(type(val), val)
val = int('a', 16)
print(type(val), val)

val = int('0b1010', 2)
print(type(val), val)
val = int('1010', 2)
print(type(val), val)

val = int('101', 3)
print(type(val), val)

val = int('60', 5)
print(type(val), val)

# 结果均为  10

使用 int() 函数的时候要主要注意一点，如果提供的字符串不能转换成指定进制的数字，那么会报异常，就像下面这样，所以在使用这个函数的时候最好放到 try 语句中。

val = int('128', 2)

'''
Traceback (most recent call last):
  File "D:\python\convert\convert.py", line 41, in 
    val = int('128', 2)
ValueError: invalid literal for int() with base 2: '128'
[Finished in 0.1s with exit code 1]
'''

什么是bytes

在列举 bytes 相关的转化前，我们来先认识一下这个类型，在 Python3 中 int、str、bytes 类型的变量实际上都是一个 “类” 的对象，而 bytes 相比 str 而言更接近底层数据，也更接近存储的形式，它其实是一个字节的数组，类似于 C 语言中的 char []，每个字节是一个范围在 0-255 的数字。

bytes 其实就是这样一连串的数字，计算机世界所有的信息都可以用这样一串数字表示，一幅画，一首歌，一部电影等等，如果对编码感兴趣可以看看这篇《简单聊聊01世界中编码和解码这对磨人的小妖儿》，现在清楚bytes是什么了，我们可以看看和它相关的转化了。

int -> bytes

使用 to_bytes() 转换成定长bytes

num = 4665
val = num.to_bytes(length=4, byteorder='little', signed=False)
print(type(val), val)

# b'9\x12\x00\x00'

这段代码就是把数字 4665 转化成定长的4个字节，字节序为小端，我们来简单看一下是怎么转换的：

上面我们提到 bytes 类型一串 0-255 范围的数字，4665 肯定超出了这个范围，可以先转化成256进制，就变成了 <18><57>，也就是 4665 = 18 * 256 + 57，我们发现两个字节就能存储这个数字，一个18，一个57，要想组成4个字节的数组需要补充两个空位，也就是补充两个0，这时就涉及到一个排列顺序，是 [0,0,18,57] 还是 [57, 18, 0, 0] 呢，这就是函数参数中的字节序 byteorder，little 表示小端，big 表示大端，这里选择的小端 [57, 18, 0, 0] 的排列。

看到这里可能会迷糊，好像和结果不一样啊，其实这只是一个表示问题，57 的 ASCII 码对应这个字符 ‘9’，18 表示成16进制就是 ‘0x12’，这里写成 b’9\x12\x00\x00’ 只是便于识别而已，实际上内存存储的就是 [57, 18, 0, 0] 这一串数字对应的二进制编码 ‘00111001 00010010 00000000 00000000’。

使用 bytes() 函数把int数组转成bytes

参考上面的生成的数组，可以通过数组生成相同的结果

num_array = [57, 18, 0, 0]
val = bytes(num_array)
print(type(val), val)

# b'9\x12\x00\x00'

使用 struct.pack() 函数把数字转化成bytes

num = 4665
val = struct.pack(", num)
print(type(val), val)

# b'9\x12\x00\x00'

这里的 " 表示将一个整数转化成小端字节序的4字节数组，其他的类型还有：

参数	含义
>	大端序
<	小端序
B	uint8类型
b	int8类型
H	uint16类型
h	int16类型
I	uint32类型
i	int32类型
L	uint64类型
l	int64类型
s	ascii码，s前带数字表示个数

bytes -> int

明白了上面的转化过程，从 bytes 转化到 int 只需要反着来就行了

使用 from_bytes() 把 bytes 转化成int

bys = b'9\x12\x00\x00'
val = int.from_bytes(bys, byteorder='little', signed=False)
print(type(val), val)

# 4665

使用 struct.unpack() 把 bytes 转化成int

bys = b'9\x12\x00\x00'
val = struct.unpack(", bys)
print(type(val), val)

# (4665,)

str 和 bytes

前面的这些转化还算清晰，到了字符串str 和字节串 bytes，就开始进入了混沌的状态，这里会出现各种编码，各种乱码，各种报错，牢记一点 str 到 bytes 是编码过程，需要使用 encode() 函数， bytes 到 str 是解码过程，需要使用 decode() 函数，请勿使用 str 函数，否则后果自负。

使用 encode() 函数完成 str -> bytes

s = '大漠孤烟直qaq'
val = s.encode('utf-8')
print(type(val), val)

#  b'\xe5\xa4\xa7\xe6\xbc\xa0\xe5\xad\xa4\xe7\x83\x9f\xe7\x9b\xb4qaq'

使用 decode() 函数完成 bytes -> str

bys = b'\xe5\xa4\xa7\xe6\xbc\xa0\xe5\xad\xa4\xe7\x83\x9f\xe7\x9b\xb4qaq'
val = bys.decode('utf-8')
print(type(val), val)

#  大漠孤烟直qaq

假如使用了 str() 函数

从上面来看字符串和字节串的转化蛮简单的，甚至比整数的转化都要简单，但是你如果把一个 bytes 变量用 str() 转化成字符串，你就得手动来处理了，这个函数写过n次了，暂时还没找到好的处理办法。

bys = b'\xe5\xa4\xa7\xe6\xbc\xa0\xe5\xad\xa4\xe7\x83\x9f\xe7\x9b\xb4qaq'
s = str(bys)
print(type(s), s)
# b'\xe5\xa4\xa7\xe6\xbc\xa0\xe5\xad\xa4\xe7\x83\x9f\xe7\x9b\xb4qaq'

def str2bytes(str_content):
    result_list = [];
    pos = 0
    str_content = str_content.replace("\\n", "\n").replace("\\t", "\t").replace("\\r", "\r")
    content_len = len(str_content)
    while pos < content_len:
        if str_content[pos] == '\\' and pos + 3 < content_len and str_content[pos + 1] == 'x':
            sub_str = str_content[pos + 2: pos + 4]
            result_list.append(int(sub_str, 16))
            pos = pos + 4
        else:
            result_list.append(ord(str_content[pos]))
            pos = pos + 1
    return bytes(result_list)

val = str2bytes(s[2:-1])
print(type(val), val)

#  b'\xe5\xa4\xa7\xe6\xbc\xa0\xe5\xad\xa4\xe7\x83\x9f\xe7\x9b\xb4qaq'

什么时候会遇到这种情况，就是有些数据是以 bytes 的形式给的，但是经过中间人复制转发变成了字节流形式的字符串，格式还不统一，有些已经翻译成了字符，有些还保留了0x或者\x形式，这时就要手工处理了。

转化表格

上面的转化方式和解释穿插在一起有些乱，这里总结一个表格，便于今后拿来就用

源类型	目标类型	方式	结果
int	str	str(10)、'{0}'.format(10)	10 => '10'
int	str（16进制）	hex(10)	10 => '0xa'
int	str（2进制）	bin(10).replace('0b','')	10 => '1010'
str	int	int('10')	'10' => 10
str（16进制）	int	int('0xa', 16)	'0xa' => 10
str（2进制）	int	int('1010', 2)	'1010' => 10
int	bytes	num.to_bytes(length=4, byteorder='little', signed=False)	4665 => b'9\x12\x00\x00'
int	bytes	struct.pack("	4665 => b'9\x12\x00\x00'
bytes	int	int.from_bytes(b'9\x12\x00\x00', byteorder='little', signed=False)	b'9\x12\x00\x00' => 4665
bytes	int	struct.unpack("	b'9\x12\x00\x00' => 4665
int[]	bytes	bytes([57, 18, 0, 0])	[57, 18, 0, 0] => b'9\x12\x00\x00'
bytes	int[]	[x for x in b'9\x12\x00\x00']	b'9\x12\x00\x00' => [57, 18, 0, 0]
str	bytes	'美好'.encode('utf-8')	'美好' => b'\xe7\xbe\x8e\xe5\xa5\xbd'
str	bytes	bytes('美好', 'utf-8')	'美好' => b'\xe7\xbe\x8e\xe5\xa5\xbd'
bytes	str	b'\xe7\xbe\x8e\xe5\xa5\xbd'.decode('utf-8')	b'\xe7\xbe\x8e\xe5\xa5\xbd' => '美好'
bytes	bytes（无\x）	binascii.b2a_hex(b'\xe7\xbe\x8eqaq')	b'\xe7\xbe\x8eqaq' => b'e7be8e716171'
bytes	bytes（有\x）	binascii.a2b_hex(b'e7be8e716171')	b'e7be8e716171' => b'\xe7\xbe\x8eqaq'
bytes	str（hex）	b'\xe7\xbe\x8eqaq'.hex()	b'\xe7\xbe\x8eqaq' => 'e7be8e716171'
str（hex）	bytes	bytes.fromhex('e7be8e716171')	'e7be8e716171' => b'\xe7\xbe\x8eqaq'

总结

• Python3 对字符串和二进制数据流做了明确的区分，不会以任意隐式的方式混用 str 和 bytes
• bytes 类型是一种比特流，它的存在形式是 01010001110 的形式，需要解码成字符才容易被人理解
• struct 模块中的 pack() 和 unpack() 可以实现任意类型和 bytes 之间的转换
• binascii.b2a_hex 和 binascii.a2b_hex 可以实现16进制 bytes 的不同形式转换，不过转换前后长度发生了变化

---

==>> 反爬链接，请勿点击，原地爆炸，概不负责！<<==

---

初识不知曲中意，再闻已是曲中人