精美排版需要请全文复制到 notepad++ 内查看，专治排版强迫症
使用 Alt + 0 全部收起，方便速查及浏览
数字 <class 'int'>
整数 -1 0 1
浮点 -0.1 0.0 1.0
二进制 0b11 ## 等于(10进制) 3
八进制 0o77 ## 等于(10进制) 63
16进制 0xFF ## 等于(10进制) 255
字符串 <class 'str'>
纯字符串 'str' "str" '''str''' """str"""
字符串数字(二进制 0b) '0b10' 转成字符 str(0b10) 结果 '2' ## 可以前置补零str(0b00000010)
字符串数字(八进制 0o) '0o77' 转换字符 str(0o77) 结果 '63' ## 可以前置补零str(0o0077)
字符串数字(十进制) '100' 转换字符 str(100) 结果 '100' ## 不能前置补零
字符串数字(16进制 0x) '0xFF' 转换字符 str(0xFF) 结果 '255' ## 可以前置补零str(0x00FF)
二进制 <class 'bytes'>
二进制字节表示 b'' ## ASCII 字符 0-9 a-z A-Z 等
b'00' == b'\x00' ## False
相互转换
数字'int'
字符'str'
字节'bytes'
数字'int' ==> 数字'int'
数字'int' ==> 字符'str'
数字'int' ==> 字节'bytes'
字符'str' ==> 字符'str'
字符'str' ==> 数字'int'
字符'str' ==> 字节'bytes'
字符形式的二进制数字'str' '0b10'
字符形式的八进制数字'str' '0o77'
字符形式的十进制数字'str' '255'
字符形式的16进制数字'str' '0xFF'
字节'bytes' ==> 字节'bytes'
字节'bytes' ==> 数字'int'
字节'bytes' ==> 字符'str'
#■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
## 二进制 八进制 十进制 16进制
数字'int' ==> 数字'int'
# 数字用于计算
# 可以用各种进制表示同一个数，不影响计算结果
0b10000000 + 0o200 + 128 + 0x80 ## 计算结果 512
0b10000000 ## 十进制值 128 的(二进制 0b)书写形式
0o200 ## 十进制值 128 的(八进制 0o)书写形式
128 ## 十进制值 128 的(十进制 )书写形式
0x80 ## 十进制值 128 的(16进制 0x)书写形式
#■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
数字'int' ==> 字符'str'
十进制'int' 255 bin(255) ==> '0b11111111' 字符形式的二进制数字'str'
十进制'int' 255 oct(255) ==> '0o377' 字符形式的八进制数字'str'
十进制'int' 255 str(255) ==> '255' 字符形式的十进制数字'str'
十进制'int' 255 hex(255) ==> '0xff' 字符形式的16进制数字'str'
二进制'int' 0b11111111 bin(0b11111111) ==> '0b11111111' 字符形式的二进制数字'str'
二进制'int' 0b11111111 oct(0b11111111) ==> '0o377' 字符形式的八进制数字'str'
二进制'int' 0b11111111 str(0b11111111) ==> '255' 字符形式的十进制数字'str'
二进制'int' 0b11111111 hex(0b11111111) ==> '0xff' 字符形式的16进制数字'str'
16进制'int' 0xff bin(0xff) ==> '0b11111111' 字符形式的二进制数字'str'
16进制'int' 0xff oct(0xff) ==> '0o377' 字符形式的八进制数字'str'
16进制'int' 0xff str(0xff) ==> '255' 字符形式的十进制数字'str'
16进制'int' 0xff hex(0xff) ==> '0xff' 字符形式的16进制数字'str'
#■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
字符'str' ==> 数字'int'
字符形式的二进制数字'str' ==> 十进制'int'
int('100',2) 4 ## 二进制的 100 等于 十进制的 4（可以不加前置 0b）
int('0b100',2) 4 ## 二进制的 100 等于 十进制的 4
int('0b0100',2) 4 ## 可以前置补零
字符形式的十进制数字'str' ==> 十进制'int'
int('123',10) 123 ## 十进制字符转十进制数字
int('123') 123 ## 默认是十进制
字符形式的16进制数字'str' ==> 十进制'int'
int('a',16) 10 ## 16进制的 a 等于 十进制的 10（可以不加前置 0x）
int('0xa',16) 10 ## 16进制的 a 等于 十进制的 10
int('0x0a',16) 10 ## 16进制的 a 等于 十进制的 10（可以前置补零）
int('10',16) 16 ## 16进制的10 等于 十进制的 16（可以不加前置 0x）
int('0x10',16) 16 ## 16进制的10 等于 十进制的 16
int('0x0010',16) 16 ## 16进制的10 等于 十进制的 16（可以前置补零）
#■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
## 单字节数字 多字节数字 大端小端表示
数字'int' ==> 字节'bytes'
import struct
# B 单字节(1byte)无符号 可以表示的数字范围 0 <= number <= 255 字节表示范围 b'\x00' 到 b'\xff'
# b 单字节(1byte)有符号 可以表示的数字范围 -128 <= number <= 127 字节表示范围 b'\x80' 到 b'\x7f'
# I 4字节(4bytes)无符号 可以表示的数字范围 0 <= number <= 4294967295
# i 4字节(4bytes)有符号 可以表示的数字范围 -2147483648 <= number <=2147483647
# 10进制数 转 字节码（内容是二进制，用16进制显示）
struct.pack('B',0) b'\x00'
struct.pack('B',1) b'\x01'
struct.pack('B',101) b'e' ## 101 对应 16进制的 0x65（此处返回值是显示为当前整数 101 对应的 ASCII字符 e）
struct.pack('B',255) b'\xff' ## 无符号最大单字节可以表示的数字
struct.pack('>i',255) b'\x00\x00\x00\xff' ## 4字节大端表示的数字(数字的高位在前)
struct.pack('<i',255) b'\xff\x00\x00\x00' ## 4字节小端表示的数字(数字的低位在前)
# 2进制数 转 字节码
struct.pack('B',0b11111111) b'\xff'
struct.pack('>i',0b111) b'\x00\x00\x00\x07' ## 0b111 等于 7（10进制）
struct.pack('>i',0b1111) b'\x00\x00\x00\x0f' ## 0b1111 等于 15（10进制）
struct.pack('>i',0b11111) b'\x00\x00\x00\x1f' ## 0b11111 等于 31（10进制）
# 16进制数 转 字节码
struct.pack('B',0xff) b'\xff'
struct.pack('>i',0xfff) b'\x00\x00\x0f\xff'
#■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
字节'bytes' ==> 数字'int' ## 受到数字字节长度、大端小端的影响
import struct
二进制内容16进制表现'bytes' 十进制值'int'
struct.unpack('B', b'\xff') (255,) ## 单字节
struct.unpack('>i', b'\x00\x00\x00\xff') (255,) ## 4字节，大端模式
struct.unpack('<i', b'\x00\x00\x00\xff') (-16777216,) ## 4字节，小端模式
#■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
## 中文字符 英文字符 数字字符 混合字符
字符'str' ==> 字节'bytes' ## 字符串 转成 字节码（可以设置字符集）
## encode()
'中文'.encode('GBK') ## b'\xd6\xd0\xce\xc4'
'中文'.encode('GB2312') ## b'\xd6\xd0\xce\xc4'
'中文'.encode('GB18030') ## b'\xd6\xd0\xce\xc4'
'中文'.encode('BIG5') ## b'\xa4\xa4\xa4\xe5'
'中文'.encode('UTF8') ## b'\xe4\xb8\xad\xe6\x96\x87'
'Python3编程'.encode('UTF-8') ## b'Python3\xe7\xbc\x96\xe7\xa8\x8b'
'ABC中文'.encode('ASCII', errors='ignore') ## b'ABC' ## 忽略错误的字节（不在字符集内的字节）
'ABC'.encode('ASCII') ## b'ABC'
'ABC'.encode('UTF8') ## b'ABC'
'ABC'.encode('GB2312') ## b'ABC'
'ABC'.encode('GB18030') ## b'ABC'
'ABC'.encode('BIG5') ## b'ABC'
'1'.encode('ASCII') ## b'1'
'1'.encode('UTF8') ## b'1'
## bytes()
bytes('abc','utf-8') ## b'abc'
bytes('编程','utf-8') ## b'\xe7\xbc\x96\xe7\xa8\x8b'
bytes('Python3编程','utf-8') ## b'Python3\xe7\xbc\x96\xe7\xa8\x8b'
## bytes.fromhex()
'''以16进制数字写的字符串，直接转成一样的字节码（2个16进制字符才是一个字节）'''
bytes.fromhex('01') ## b'\x01' # 单字节
bytes.fromhex('0001') ## b'\x00\x01' # 双字节
bytes.fromhex('aabbccddeeff') ## b'\xaa\xbb\xcc\xdd\xee\xff' # 多字节
## struct.pack(格式,内容)
S = 'Python3编程' ## 'Python3编程'
B = bytes(S,'utf-8') ## b'Python3\xe7\xbc\x96\xe7\xa8\x8b'
FMT = str(len(B)) + 's' ## '13s'
struct.pack(FMT,B) ## b'Python3\xe7\xbc\x96\xe7\xa8\x8b'
#■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
字节'bytes' ==> 字符'str'
## decode()
b'abc'.decode('UTF-8') ## 'abc'
b'Python3\xe7\xbc\x96\xe7\xa8\x8b'.decode('UTF-8') ## 'Python3编程'
## .hex()
'''每一个字符转成2位16进制表示'''
b'0'.hex() '30' 0x30 == 48 ## 字符'0'在ASCII码上的数字（数字是16进制表示）== 48（十进制）
b'1'.hex() '31' 0x31 == 49
b'A'.hex() '41' 0x41 == 65
b'Z'.hex() '5a' 0x5a == 90
b'a'.hex() '61' 0x61 == 97
b'z'.hex() '7a' 0x7a == 122
b'00'.hex() '3030'
b'AAa'.hex() '414161'
b'\xaa\xbb\xcc\xdd\xee\xff'.hex() ## 'aabbccddeeff'
b'aabbccddeeff'.hex() ## '616162626363646465656666'
#■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
'''综合应用：字符集转换'''
G = '中文'.encode('GBK') ## b'\xd6\xd0\xce\xc4' 原GBK编码的字符串
U = '中文'.encode('UTF8') ## b'\xe4\xb8\xad\xe6\x96\x87' 要转成UTF8编码的字符串，用于验证测试
TEXT = G.decode('GBK') ## '中文' 先用原编码解析
NEW = TEXT.encode('UTF8') ## b'\xe4\xb8\xad\xe6\x96\x87' 再用新编码进行编码
NEW == U ## True 验证相同
## 其他
ASCII 字符 和 数字
字节 b'\x05'
字符串 '\x05'
## 将一个整数 (0-1114111) 转换为 一个字符（整数对应的 ASCII 字符）
## ValueError: chr() arg not in range(0x110000)
>>> chr(0) '\x00'
>>> chr(1) '\x01'
>>> chr(97) 'a'
>>> chr(1114111) '\U0010ffff'
>>> len(chr(101)) 1 # 长度为 1个字符
>>> len(chr(1114111)) 1 # 长度为 1个字符
## 将一个 ASCII字符 转换为 一个整数
>>> ord('\x00') 0
>>> ord('\x01') 1
>>> ord('a') 97
>>> ord('0') 48
>>> ord('1') 49
>>> ord('A') 65
>>> ord('Z') 90
>>> ord('\U0010ffff') 1114111
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
ASCII 字符 和 字节
from binascii import b2a_hex, a2b_hex
>>> a2b_hex('ab')
b'\xab'
>>> b2a_hex(b'ab')
b'6162'
>>> a2b_hex(b'6162')
b'ab'
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
struct
## 打包成二进制 struct.pack(fmt, v1, v2, ...)
## 把二进制解包 struct.unpack(fmt, bytes)
## 根据描述的格式返回该结构的大小 calcsize(fmt)
Format C Type Python 字节数
c char 1
？ _Bool bool 1 未必可用
i int integer 4
I unsigned int integer 4
q long long integer 8 仅适用于64位系统
Q unsigned long long integer 8 仅适用于64位系统
f float float 4
d double float 8
s char[] bytes 1
B 1bytes 1 struct.pack('B', 数字) # 0 <= 数字 <= 255 # b'\x00' 到 b'\xff'
Format C Type Python type Standard size Notes
x pad byte no value
c char string of length 1 1
b signed char integer 1 (3)
B unsigned char integer 1 (3)
? _Bool bool 1 (1)
h short integer 2 (3)
H unsigned short integer 2 (3)
i int integer 4 (3)
I unsigned int integer 4 (3)
l long integer 4 (3)
L unsigned long integer 4 (3)
q long long integer 8 (2), (3)
Q unsigned long long integer 8 (2), (3)
f float float 4 (4)
d double float 8 (4)
s char[] string
p char[] string
P void * integer (5), (3)
< little-endian 小端
> big-endian 大端
! network (= big-endian) 网络端（大端）
>>> struct.pack('>i',1) 大端 b'\x00\x00\x00\x01'
>>> struct.pack('<i',1) 小端 b'\x01\x00\x00\x00'
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
print() 能识别字符的 \n，不能识别字节的 \n
## 字符串
AA = 'a\nb'
>>> print(AA)
a
b
## 字符串 => 字节码
BB = bytes('a\nb','utf-8')
>>> print(BB)
b'a\nb'
## 字节码 => 字符串
CC = BB.decode('UTF-8')
>>> print(CC)
a
b
698
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
