วิธีที่ดีที่สุดในการเข้ารหัสสตริงไบนารีที่ยาวมากเป็นรูปแบบง่ายๆที่สามารถเปลี่ยนกลับได้โดยใช้ Python?
-------------------------- เพิ่มใหม่---------------------- -------
ให้ฉันกรอกข้อมูลเพิ่มเติมที่นี่:
สถานการณ์จริงคือฉันมีความยาวนี้ในสภาพแวดล้อม -A และฉันจำเป็นต้องคัดลอกและวางลงในสภาพแวดล้อม -B
UNFORTUNATELY ไม่ได้เชื่อมต่อ envir-A และ envir-B (ไม่มีการเข้าถึงร่วมกัน) ดังนั้นฉันกำลังคิดหาวิธีเข้ารหัส / ถอดรหัสเพื่อเป็นตัวแทนมิฉะนั้นสำหรับไฟล์เพิ่มเติมฉันต้องป้อนสตริงด้วยมือด้วยมือ - - ซึ่งช้าและไม่สามารถทำซ้ำได้
ข้อเสนอแนะหรืออุปกรณ์แนะนำ? ขอบคุณมาก!
ฉันกำลังประสบปัญหาแปลก ๆ ในการเข้ารหัสไบนารี SUPER LONG เป็นรูปแบบง่ายๆเช่นตัวเลขหลายหลัก
สมมติว่ามีสตริงที่ยาวประกอบด้วย 1 และ 0 เท่านั้นเช่น "110 ... 011" ที่มีความยาว 1,000 ถึง 100,000 หรือมากกว่านั้นและฉันต้องการเข้ารหัส STRING นี้เป็นสิ่งที่มีตัวเลข / ตัวอักษรน้อยกว่า จากนั้นฉันต้องย้อนกลับกลับไปเป็น STRING ดั้งเดิม
ตอนนี้ฉันกำลังลองใช้วิธี hex / int ใน Python เพื่อ 'บีบอัด' สตริงนี้และ 'คลายการบีบอัด' กลับเป็นรูปแบบดั้งเดิม
ตัวอย่างจะเป็น:
1. สตริงอินพุต: '110011110110011'
'' '
def Bi_to_Hex_Int(input_str, method ):
#2to16
if method=='hex':
string= str(input_str)
input_two= string
result= hex(int(input_two,2))
#2to10
if method=='int':
string= str(input_str)
input_two= string
result= int(input_two,2)
print("input_bi length",len(str(input_two)), "\n output hex length",len(str(result)),'\n method: {}'.format(method) )
return result
res_16 =Bi_to_Hex_Int(gene , 'hex')
=='0x67b3'
res_10 =Bi_to_Hex_Int(gene , 'int')
== 26547
'' '
จากนั้นฉันสามารถย้อนกลับได้:
'' '
def HexInt_to_bi(input_str , method):
if method =='hex':
back_two = bin(int(input_str,16))
back_two = back_two[2:]
if method =='int':
back_two = bin( int(input_str ))
back_two = back_two[2:]
print("input_hex length",len(str(input_str)), "\n output bi length",len(str(back_two)) )
return back_two
hexback_two = HexInt_to_bi(res_16, 'hex')
intback_two = HexInt_to_bi(res_10 , 'int')
'' '
แต่สิ่งนี้มีปัญหาฉันลองใช้ String ประมาณ 500 หลัก: 101010 ... 0001 (500d) ผลลัพธ์ 'บีบอัด' ที่ดีที่สุดคือประมาณ 127 หลักโดยฐานสิบหก
ดังนั้นมีวิธีที่ดีกว่าในการ 'บีบอัด' สตริงให้มีตัวเลขน้อยลงหรือไม่?
** พูดว่าสตริง 5,000 หลักประกอบด้วย 1s & 0s บีบอัดเป็น 50/100 บางอย่างของตัวเลข / ตัวอักษร (ต่ำกว่า) ** ??
คำตอบ
ถ้าคุณอยากให้มันง่าย ๆ ให้พูดว่าอักขระเลขฐานสิบหก 1 ตัวจะบีบอัดอักขระไบนารี 4 ตัว (2 ^ 4 = 16) อัตราส่วนการบีบอัดที่คุณต้องการคือประมาณ 100/50 เท่า เป็นเวลา 50 ครั้งคุณต้องบีบอัดอักขระไบนารี 50 ตัวเป็นอักขระ 1 ตัวหมายความว่าคุณต้องใช้อักขระที่แตกต่างกัน 2 ^ 50 อักขระในการเข้ารหัสชุดค่าผสมใด ๆ ค่อนข้างมากนั่นก็คือ
ถ้าคุณยอมรับอัตราส่วนที่ต่ำกว่าคุณอาจลอง base64 เหมือนที่อธิบายไว้ที่นี่ อัตราส่วนการบีบอัดคือ 6 ต่อ 1
มิฉะนั้นคุณจะต้องใช้อัลกอริทึมที่ซับซ้อนบางอย่างเช่นการแยกสตริงของคุณออกเป็นบล็อกค้นหาสิ่งที่คล้ายกันเข้ารหัสด้วยสัญลักษณ์ที่แตกต่างกันสร้างแผนที่ของสัญลักษณ์เหล่านั้นเป็นต้น
อาจจะง่ายกว่าที่จะบีบอัดสตริงของคุณด้วยไฟล์เก็บถาวรจากนั้นส่งคืนการแสดงผล base64
หากงานอนุญาตคุณสามารถจัดเก็บสตริงทั้งหมดไว้ที่ใดที่หนึ่งและตั้งชื่อเฉพาะสั้น ๆ ดังนั้นแทนที่จะบีบอัดและคลายการบีบอัดคุณต้องจัดเก็บและเรียกสตริงตามชื่อ
สิ่งนี้อาจไม่ได้สร้างสตริงที่สั้นที่สุดที่คุณจะได้รับ แต่มันง่ายมากเมื่อใช้สิ่งอำนวยความสะดวกที่มีอยู่ใน Python ไม่จำเป็นต้องแปลงอักขระเป็นรูปแบบไบนารีการzlib
บีบอัดจะแปลงอินพุตที่มีเพียง 2 อักขระที่แตกต่างกันให้เป็นสิ่งที่เหมาะสมที่สุด
การเข้ารหัส:
import zlib
import base64
result = base64.b64encode(zlib.compress(input_str.encode()))
หากจำนวน0
และ1
มีนัยสำคัญแตกต่างจากที่คุณสามารถใช้การเข้ารหัสแบบแจกแจงเพื่อให้ได้การแสดงที่สั้นที่สุด
ถ้าสตริงประกอบด้วยเพียงของ0
และ1
ตัวเลขแล้วคุณสามารถแพ็คแปดหลักเป็นหนึ่งไบต์ นอกจากนี้คุณจะต้องติดตามจำนวนตัวเลขที่ผ่านมาจากตัวคูณสุดท้ายของแปดเนื่องจากไบต์สุดท้ายอาจมีค่าน้อยกว่าแปดหลัก