Melhor maneira de codificar uma string de binários muito longa para uma forma simples reversível usando Python?
-------------------------- adicionar novo---------------------- -------
Deixe-me preencher mais informações aqui:
A situação real é que tenho este LONG STRING no ambiente-A e preciso copiá-lo e colá-lo no ambiente-B;
INFELIZMENTE, envir-A e envir-B não estão conectados (sem acesso mútuo), então estou pensando em uma maneira de codificar / decodificar para representá-lo, caso contrário, para mais arquivos eu tenho que inserir a string manualmente --- -que é lento e não reproduzível.
Alguma sugestão ou recomendação de gadget? Muito Obrigado!
Estou enfrentando um problema estranho para codificar binários SUPER LONG para uma forma simples, como vários dígitos.
Digamos que haja uma string longa composta por apenas 1 e 0, por exemplo, "110 ... 011" de comprimento 1.000 a 100.000 ou até mais dígitos, e eu gostaria de codificar esta STRING para algo que tenha menos dígitos / caracteres. Então, preciso reverter para o STRING original.
Atualmente estou tentando usar o método hex / int em Python para 'compactar' esta String e 'descompactá-la' de volta à forma original.
Um exemplo seria:
1. string de entrada: '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
'' '
Então eu posso reverter de volta:
'' '
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')
'' '
MAS, isso tem um problema, tentei cerca de 500 dígitos de String: 101010 ... 0001 (500d), o melhor resultado 'compactado' é em torno de 127 dígitos por hexadecimal;
Então, há uma maneira melhor de 'compactar' ainda mais a string para menos dígitos?
** Digamos que 5.000 dígitos da string consistam em 1s e 0s, comprima para 50/100 algo de dígitos / caracteres (ainda mais baixo) ** ??
Respostas
Se você quiser tão simples, digamos que 1 caractere hexadecimal comprime 4 caracteres binários (2 ^ 4 = 16). A taxa de compressão desejada é de cerca de 100/50 vezes. Por 50 vezes você precisa de 50 caracteres binários para serem compactados em 1 caractere, significa que você precisa de 2 ^ 50 caracteres diferentes para codificar qualquer combinação. Bastante isso.
Se você aceitar uma proporção mais baixa, pode tentar base64 conforme descrito aqui . Sua taxa de compressão é de 6 para 1.
Caso contrário, você terá que criar algum algoritmo complexo, como dividir sua string em blocos, procurar similares entre eles, codificá-los com símbolos diferentes, construir um mapa desses símbolos, etc.
Provavelmente é mais fácil compactar sua string com um arquivador e , em seguida, retornar uma representação base64 do resultado.
Se a tarefa permitir, você pode armazenar as strings inteiras em algum lugar e dar-lhes nomes curtos e exclusivos, portanto, em vez de compactar e descompactar, você precisa armazenar e recuperar strings por nomes.
Isso provavelmente não produz a string mais curta que você pode obter, mas é trivialmente fácil usar os recursos integrados ao Python. Não há necessidade de converter os caracteres em um formato binário, a zlib
compressão irá converter uma entrada com apenas 2 caracteres diferentes em algo ideal.
Codificação:
import zlib
import base64
result = base64.b64encode(zlib.compress(input_str.encode()))
Se a contagem de 0
e 1
for significativamente diferente do que você pode usar a codificação enumerativa para obter a representação mais curta
Se a string consistir apenas em dígitos 0
e 1
, você pode compactar oito dígitos em um byte. Você também precisará controlar quantos dígitos passaram do último múltiplo de oito, já que o último byte pode representar menos de oito dígitos.