LƯU Ý 1. Tất cả các ví dụ trong trang này được viết bằng Python 3. x. Nó có thể không hoạt động nếu bạn sử dụng Python 2. x
LƯU Ý 2. Tất cả các ví dụ trong trang này được cho là được viết/chạy trên Windows 7 trừ khi được đề cập cụ thể. Bạn CÓ THỂ [hoặc không] cần sửa đổi cú pháp một chút nếu bạn đang chạy trên hệ điều hành khác
Chuyển đổi một số thành một chuỗi
< Ví dụ 1 >
in["str[123]=",str[123]]
in["str[12345678901234567890]=",str[12345678901234567890]]
in["str[0xA]=",str[0xA]]
in["str[0xAB]=",str[0xAB]]
in["str[0xABC]=",str[0xABC]]
in["str[0b1]=",str[0b1]]
in["str[0b0111]=",str[0b0111]]
in["str[0b11111111]=",str[0b11111111]]
Kết quả. ----------------------------------
str[123]= 123
str[12345678901234567890]= 12345678901234567890
str[0xA]= 10
str[0xAB]= 171
str[0xABC]= 2748
str[0b1]= 1
str[0b0111]= 7
str[0b11111111]= 255
Chuyển đổi chuỗi Hex thành số nguyên
< Ví dụ 1 >
>>> str[0xABC]
'2748'
< Ví dụ 2 >
>>> str[0xabc]
'2748'
< Ví dụ 3 >
# Nếu bạn đặt số hex ở định dạng chuỗi, str[] sẽ không chuyển đổi nó thành số nguyên
>>> str['0xABC']
'0xABC'
< Ví dụ 4 >
>>> int['0xABC',16]
2748
Chuyển đổi một số nguyên thành chuỗi hex
< Ví dụ 1 >
>>> lục giác [2748]
'0xabc'
Chuyển đổi một số nguyên thành chuỗi nhị phân
< Ví dụ 1 >
>>> thùng [2748]
'0b101010111100'
< Ví dụ 2 >
>>> bin[2748][2. ]
'101010111100'
< Ví dụ 3 >
>>> '{0. 016b}'. định dạng[2748]
'0000101010111100'
Chuyển đổi một chuỗi nhị phân thành một số nguyên
< Ví dụ 1 >
>>> int['0b101010111100',2]
2748
< Ví dụ 2 >
>>> str[0b101010111100]
'2748'
Chuyển đổi ký tự ASCII thành Mảng Byte
< Ví dụ 1 >
numStr = "123ABCDEF"
bArray = bytearray[numStr. mã hóa ['ascii']]
in [bArray]
cho b trong numStr
print["các phần tử trong numStr. ", b]
cho b trong bArray
print["các phần tử trong bArray. ", b]
Kết quả. ----------------------------------
mảng phụ[b'123ABCDEF']
các phần tử trong numStr. 1
các phần tử trong numStr. 2
các phần tử trong numStr. 3
các phần tử trong numStr. Một
các phần tử trong numStr. b
các phần tử trong numStr. C
các phần tử trong numStr. Đ.
các phần tử trong numStr. e
các phần tử trong numStr. F
phần tử trong bArray. 49
phần tử trong bArray. 50
phần tử trong bArray. 51
phần tử trong bArray. 65
phần tử trong bArray. 66
phần tử trong bArray. 67
phần tử trong bArray. 68
phần tử trong bArray. 69
phần tử trong bArray. 70
Chuyển đổi Chuỗi Hex thành luồng Số Hex [gói binascii]
< Ví dụ 1 >
nhập khẩu binascii
hexStr = "AABBCC"
hexNumbers = binascii. a2b_hex[hexStr]
in["hexStr = ",hexStr]
print["Số hex = ", Số hex]
Kết quả. ----------------------------------
hexStr = AABBCC
hexNumbers = b'\xaa\xbb\xcc'
Chuyển đổi một luồng Số Hex thành Mảng Byte [bytearray,binascii]
< Ví dụ 1 >
nhập khẩu binascii
hexStr = "AABBCC"
hexNumbers = binascii. a2b_hex[hexStr]
byteArray = bytearray[hexNumbers]
in["hexStr = ",hexStr]
print["Số hex = ", Số hex]
in["byteArray = ", byteArray]
in["hexStr[0]=",hexStr[0]]
print["Số hex[0]=",Số hex[0]]
in["byteArray[0]=",byteArray[0]]
Kết quả. ----------------------------------
hexStr = AABBCC
hexNumbers = b'\xaa\xbb\xcc'
byteArray = bytearray[b'\xaa\xbb\xcc']
hexStr[0]= A
hexNumbers[0]= 170
byteArray[0]= 170
Chuyển đổi một ByteArray thành một chuỗi số Hex [bytearray,binascii]
< Ví dụ 1 >
nhập khẩu binascii
ByteAry = b'\x45\x00\x00\x16\x36\xdd\x00\x00\x80\xfd\xfe\xa7\x01\x01\x01\x64\x01\x01\x01\x01\x48\x69'
phương pháp int. to_bytes[length, byteorder, *,signed=False] trả về một đối tượng byte đại diện cho một số nguyên
>>> 0x12_84.to_bytes[2, 'big', signed=True] b'\x12\x84' >>> [-0xE2_04].to_bytes[3, 'big', signed=True] # Note the parentheses: [-0xE2_04]. b'\xff\x1d\xfc' # 3 bytes for a signed, negative int. >>>
Nếu mỗi ký tự của chuỗi phù hợp với một byte, quá trình này rất đơn giản
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>
Một listcomp đơn giản hóa quá trình
>>> b1 = bytes[ [ ord[p] for p in s1 ] ] ; b1 b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>
Ở trên thực hiện mã hóa 'Latin-1'
>>> b1a = s1.encode['Latin-1'] ; b1a b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>> b1 == b1a True >>>
Phương thức
>>> 0x12_84.to_bytes[2, 'big', signed=True] b'\x12\x84' >>> [-0xE2_04].to_bytes[3, 'big', signed=True] # Note the parentheses: [-0xE2_04]. b'\xff\x1d\xfc' # 3 bytes for a signed, negative int. >>>0 tạo đối tượng bytes chứa chuỗi mã hóa
>>> 0x12_84.to_bytes[2, 'big', signed=True] b'\x12\x84' >>> [-0xE2_04].to_bytes[3, 'big', signed=True] # Note the parentheses: [-0xE2_04]. b'\xff\x1d\xfc' # 3 bytes for a signed, negative int. >>>1
>>> s1 '\t\n\r\x0e 123 ሴ abc åæç' >>> s1.encode[] # Each character 'åæç' occupies one byte but is encoded as 2 bytes. b'\t\n\r\x0e 123 \xe1\x88\xb4 abc \xc3\xa5\xc3\xa6\xc3\xa7' # Character 'ሴ' is encoded as 3 bytes. >>> >>> s1.encode[] == s1.encode['utf-8'] # Encoding 'utf-8' is default. True >>> >>> len[s1.encode['utf-8']] 23 >>> len[s1.encode['utf-16']] # 'utf-16' and 'utf-32' are optional encodings. 38 >>> len[s1.encode['utf-32']] 76 >>>
từ str chứa văn bản quốc tế[sửa | sửa mã nguồn]. sửa nguồn]
>>> s1 = 'Γ γ Δ δ Ζ ζ Ξ ξ' # Greek >>> s1.encode[] b'\xce\x93 \xce\xb3 \xce\x94 \xce\xb4 \xce\x96 \xce\xb6 \xce\x9e \xce\xbe' # Greek encoded >>> len[s1] 15 # 8 Greek characters + 7 spaces >>> len[s1.encode[]] 23 # 8*2 + 7 >>>
Mỗi ký tự Hy Lạp chiếm 2 byte và được mã hóa thành 2 byte. lưu ý ví dụ
________số 8
>>> s1 = 'А а Б б В в Г г Щ щ Я я' # Cyrillic >>> s1.encode[] b'\xd0\x90 \xd0\xb0 \xd0\x91 \xd0\xb1 \xd0\x92 \xd0\xb2 \xd0\x93 \xd0\xb3 \xd0\xa9 \xd1\x89 \xd0\xaf \xd1\x8f' # Cyrillic encoded. >>>
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>00
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>01
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>02
từ str chứa các chữ số thập lục phân[sửa. sửa nguồn]
byte phương thức lớp. fromhex[string] trả về một đối tượng bytes, giải mã đối tượng chuỗi đã cho
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>03
byte phương thức lớp. fromhex[string] có thể được sử dụng để chuyển đổi từ đối tượng
>>> 0x12_84.to_bytes[2, 'big', signed=True] b'\x12\x84' >>> [-0xE2_04].to_bytes[3, 'big', signed=True] # Note the parentheses: [-0xE2_04]. b'\xff\x1d\xfc' # 3 bytes for a signed, negative int. >>>2 dương sang
>>> 0x12_84.to_bytes[2, 'big', signed=True] b'\x12\x84' >>> [-0xE2_04].to_bytes[3, 'big', signed=True] # Note the parentheses: [-0xE2_04]. b'\xff\x1d\xfc' # 3 bytes for a signed, negative int. >>>3
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>04
Một số thông tin kỹ thuật về tiêu chuẩn mã hóa 'utf-8'[sửa. sửa nguồn]
Các chuỗi được mã hóa theo tiêu chuẩn mã hóa 'utf-8' tuân theo bảng sau
Phạm viMã hóaMô tảU-00000000. U-0000007F0xxxxxxxBit đánh dấu '0' và 7 bit tải trọng [phù hợp với ASCII]U-00000080. U-000007FF110xxxxx 10xxxxxx Bit đánh dấu '110', '10' và 11 bit tải trọngU-00000800. U-0000FFFF1110xxxx 10xxxxxx 10xxxxxx Bit đánh dấu '1110', '10', '10' và 16 bit tải trọngU-00010000. U-0010FFFF11110xxx 10xxxxxx 10xxxxxx 10xxxxxx Bit đánh dấu '11110', '10', '10', '10' và 21 bit tải trọng
Tiêu chuẩn mã hóa 'utf-8' là một lựa chọn tốt cho mã hóa mặc định vì
- 2, 3 hoặc 4 byte chỉ được sử dụng nếu cần thiết,
- nó không phụ thuộc vào thứ tự byte, lớn hay nhỏ, và
- dữ liệu nhị phân tùy ý không có khả năng phù hợp với thông số kỹ thuật trên
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>05
Đoạn mã sau kiểm tra chr[0x10006], được mã hóa bằng 4 byte
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>06
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>07
Về mặt lý thuyết, 21 bit tải trọng có thể chứa '\U001FFFFF' nhưng tiêu chuẩn dừng ở '\U0010FFFF'
>>> s1 = '\011\012\015\016 123 abc \345\346\347' ; s1 '\t\n\r\x0e 123 abc åæç' >>> >>> L1 = [] >>> for p in s1 : L1 += [ord[p]] .. >>> L1 [9, 10, 13, 14, 32, 49, 50, 51, 32, 97, 98, 99, 32, 229, 230, 231] >>> >>> bytes[ L1 ] b'\t\n\r\x0e 123 abc \xe5\xe6\xe7' >>>08Nhược điểm của 'utf-8'[sửa | sửa mã nguồn]. sửa nguồn]
Đối tượng byte được tạo với mã hóa 'utf-8' có thể chứa byte rỗng b'\x00'. Điều này có thể gây ra sự cố nếu bạn đang gửi một luồng byte qua bộ lọc diễn giải b'\x00' là kết thúc dữ liệu. Tiêu chuẩn 'utf-8' không bao giờ tạo ra b'\xFF'. Nếu đối tượng byte của bạn không được chứa b'\x00' sau khi mã hóa, bạn có thể chuyển đổi byte rỗng thành b'\xFF', sau đó chuyển đổi b'\xFF' thành b'\x00' trước khi giải mã