Sử dụng str.format
:
>>> array_alpha = [ 133, 53, 234, 241 ]
>>> print ''.join['{:02x}'.format[x] for x in array_alpha]
8535eaf1
hoặc sử dụng format
>>> print ''.join[format[x, '02x'] for x in array_alpha]
8535eaf1
LƯU Ý: Trong các câu lệnh định dạng,
02
có nghĩa là nó sẽ đệm với tối đa 2 ____10s nếu cần thiết. Điều này rất quan trọng vì1 sẽ được định dạng thành>>> print ''.join[format[x, '02x'] for x in array_alpha] 8535eaf1
2 thay vì>>> print ''.join[format[x, '02x'] for x in array_alpha] 8535eaf1
3>>> print ''.join[format[x, '02x'] for x in array_alpha] 8535eaf1
hoặc sử dụng
>>> print ''.join[format[x, '02x'] for x in array_alpha]
8535eaf1
4 với >>> print ''.join[format[x, '02x'] for x in array_alpha]
8535eaf1
5:>>> import binascii
>>> binascii.hexlify[bytearray[array_alpha]]
'8535eaf1'
Dưới đây là một chuẩn mực của các phương thức trên trong Python 3.6.1:
from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
Result:
Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
Các phương thức sử dụng format
cung cấp các tùy chọn định dạng bổ sung, làm ví dụ tách các số với khoảng trắng
>>> print ''.join[format[x, '02x'] for x in array_alpha]
8535eaf1
7, dấu phẩy >>> print ''.join[format[x, '02x'] for x in array_alpha]
8535eaf1
8, in trường hợp trên ____ 19/________ 20, v.v., nhưng với chi phí tác động hiệu suất lớn. Xem thảo luận
Cải thiện bài viết
Lưu bài viết
Xem thảo luận
Cải thiện bài viết
Lưu bài viết
Đọc
Bàn luậnformat[] + join[] to Convert Byte Array to Hex String
Sự kết hợp của các chức năng trên có thể được sử dụng để thực hiện nhiệm vụ cụ thể này. Hàm định dạng chuyển đổi các byte thành định dạng thập lục phân. Định dạng 02 02 ở định dạng được sử dụng để pad yêu cầu hàng đầu. Hàm tham gia cho phép tham gia kết quả thập lục phân vào chuỗi. & NBSP;
Python3
Các
from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
2from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
3from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
4 from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
5 from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
6from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
7from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
8>>> import binascii
>>> binascii.hexlify[bytearray[array_alpha]]
'8535eaf1'
2 Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
0Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
1Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
2Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
3__from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
2from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
3The original string is : [124, 67, 45, 11] The string after conversion : 7c432d0b0
from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
5 from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
6The original string is : [124, 67, 45, 11] The string after conversion : 7c432d0b3
Output:
The original string is : [124, 67, 45, 11] The string after conversion : 7c432d0b
Sử dụng Binascii.hexlify [] để chuyển đổi mảng byte thành chuỗi hex
Chức năng sẵn có của hexlify có thể được sử dụng để thực hiện nhiệm vụ cụ thể này. Hàm này được khuyến nghị cho chuyển đổi cụ thể này vì nó được thiết kế riêng để giải quyết vấn đề cụ thể này. & NBSP;
Python3
The original string is : [124, 67, 45, 11] The string after conversion : 7c432d0b4
The original string is : [124, 67, 45, 11] The string after conversion : 7c432d0b5
Các
from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
2from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
3from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
4 from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
5 from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
6from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
7from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
8>>> import binascii
>>> binascii.hexlify[bytearray[array_alpha]]
'8535eaf1'
2 Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
0Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
1Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
2Testing with 255-byte bytes:
Using str.format -> 1.459474583090427
Using format -> 1.5809937679100738
Using binascii.hexlify -> 0.014521426401399307
Testing with 255-byte bytearray:
Using str.format -> 1.443447684109402
Using format -> 1.5608712609513171
Using binascii.hexlify -> 0.014114164661833684
3__from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
2from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
3The original string is : [124, 67, 45, 11] The string after conversion : 7c432d0b0
from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
5 from timeit import timeit
import binascii
number = 10000
def using_str_format[] -> str:
return "".join["{:02x}".format[x] for x in test_obj]
def using_format[] -> str:
return "".join[format[x, "02x"] for x in test_obj]
def using_hexlify[] -> str:
return binascii.hexlify[bytearray[test_obj]].decode['ascii']
def do_test[]:
print["Testing with {}-byte {}:".format[len[test_obj], test_obj.__class__.__name__]]
if using_str_format[] != using_format[] != using_hexlify[]:
raise RuntimeError["Results are not the same"]
print["Using str.format -> " + str[timeit[using_str_format, number=number]]]
print["Using format -> " + str[timeit[using_format, number=number]]]
print["Using binascii.hexlify -> " + str[timeit[using_hexlify, number=number]]]
test_obj = bytes[[i for i in range[255]]]
do_test[]
test_obj = bytearray[[i for i in range[255]]]
do_test[]
6The original string is : [124, 67, 45, 11] The string after conversion : 7c432d0b3
Output:
The original string is : [124, 67, 45, 11] The string after conversion : 7c432d0b
Sử dụng Binascii.hexlify [] để chuyển đổi mảng byte thành chuỗi hex