Der beste Weg, um eine sehr lange Binärdatei-Zeichenfolge mit Python in eine rückgängig zu machende einfache Form zu kodieren?
-------------------------- neue hinzufügen---------------------- -------
Lassen Sie mich hier weitere Informationen eingeben:
Die tatsächliche Situation ist, dass ich diesen LONG STRING in Umgebung A habe und ihn kopieren und in Umgebung B einfügen muss.
Leider sind envir-A und envir-B nicht verbunden (kein gegenseitiger Zugriff), daher denke ich über eine Möglichkeit nach, diese zu codieren / decodieren, um sie darzustellen. Andernfalls muss ich für weitere Dateien die Zeichenfolge von Hand eingeben --- -Das ist langsam und nicht reproduzierbar.
Irgendwelche Vorschläge oder Gadgets empfehlen? Vielen Dank!
Ich stehe vor einem seltsamen Problem, eine SUPER LANGE Binärdatei in eine einfache Form zu codieren, wie mehrere Ziffern.
Angenommen, es gibt eine lange Zeichenfolge, die nur aus 1 und 0 besteht, z. B. "110 ... 011" mit einer Länge von 1.000 bis 100.000 oder sogar mehr Ziffern, und ich möchte diese STRING in etwas codieren, das weniger Ziffern / Zeichen enthält. Dann muss ich es wieder auf den ursprünglichen STRING zurücksetzen.
Derzeit versuche ich, die Hex / int-Methode in Python zu verwenden, um diesen String zu "komprimieren" und ihn wieder in die ursprüngliche Form zu "dekomprimieren".
Ein Beispiel wäre:
1. Eingabezeichenfolge: '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
'' '
Dann kann ich es wieder rückgängig machen:
'' '
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')
'' '
ABER das hat ein Problem, ich habe ungefähr 500 Stellen String ausprobiert: 101010 ... 0001 (500d), das beste 'komprimierte' Ergebnis ist ungefähr 127 Stellen pro Hex;
Gibt es also eine bessere Möglichkeit, die Zeichenfolge weiter auf weniger Ziffern zu komprimieren?
** Angenommen, 5.000 Ziffern der Zeichenfolge bestehen aus 1s & 0s, komprimieren Sie etwas von Ziffern / Zeichen (noch niedriger) auf 50/100 ** ??
Antworten
Wenn Sie es so einfach wollen, sagen wir, 1 Hex-Zeichen komprimiert 4 Binärzeichen (2 ^ 4 = 16). Das gewünschte Komprimierungsverhältnis beträgt etwa das 100/50-fache. Für 50 Mal benötigen Sie 50 Binärzeichen, um zu 1 Zeichen komprimiert zu werden. Dies bedeutet, dass Sie 2 ^ 50 verschiedene Zeichen benötigen, um eine beliebige Kombination zu codieren. Das ist ziemlich viel.
Wenn Sie ein niedrigeres Verhältnis akzeptieren, können Sie base64 wie hier beschrieben ausprobieren . Das Kompressionsverhältnis beträgt 6 zu 1.
Andernfalls müssen Sie sich einen komplexen Algorithmus einfallen lassen, z. B. das Aufteilen Ihrer Zeichenfolge in Blöcke, das Suchen nach ähnlichen, das Codieren mit verschiedenen Symbolen, das Erstellen einer Karte dieser Symbole usw.
Wahrscheinlich ist es einfacher, Ihre Zeichenfolge mit einem Archivierer zu komprimieren und dann eine base64-Darstellung des Ergebnisses zurückzugeben.
Wenn die Aufgabe dies zulässt, können Sie die gesamten Zeichenfolgen irgendwo speichern und ihnen kurze eindeutige Namen geben. Statt Komprimierung und Dekomprimierung müssen Sie Zeichenfolgen nach Namen speichern und abrufen.
Dies erzeugt wahrscheinlich nicht die absolut kürzeste Zeichenfolge, die Sie erhalten können, aber es ist trivial einfach, die in Python integrierten Funktionen zu verwenden. Die Zeichen müssen nicht in ein Binärformat konvertiert werden. Durch die zlib
Komprimierung wird eine Eingabe mit nur 2 verschiedenen Zeichen in etwas Optimales konvertiert.
Codierung:
import zlib
import base64
result = base64.b64encode(zlib.compress(input_str.encode()))
Wenn sich die Anzahl von 0
und 1
signifikant von der Anzahl unterscheidet, können Sie die Aufzählungscodierung verwenden, um die kürzeste Darstellung zu erhalten
Wenn die Zeichenfolge nur aus 0
und 1
Ziffern besteht, können Sie acht Ziffern in ein Byte packen. Sie müssen auch verfolgen, wie viele Ziffern nach dem letzten Vielfachen von acht liegen, da das letzte Byte möglicherweise weniger als acht Ziffern darstellt.