Objetivo

Pegue mensagens e ordens e as compacte para arquivamento e transmissão.

Há várias instruções de construção, remessas e manifestos que foram enviados e precisam ser transferidos ou arquivados. Embora esses possam ser enviados manualmente, uma boa maneira de fazer isso é compactar e descompactar arquivos, em seguida, armazená-los ou enviá-los. Para fazer isso, você pode usar módulos de compressão para diminuir o tamanho dos arquivos e facilitar o gerenciamento das informações. Ao contrário de outros problemas que resolvemos, onde aprendemos e usamos um único módulo, existem vários módulos de compressão que podemos usar com uma pequena seleção de funções. São eles:

Para velocidade de compressão rápida e baixa compressão, use o módulo zlib, adicionando import zlib. Para nossos propósitos, usaremos a seguinte função: zlib.compress(), que usa um argumento, que é a informação que você gostaria de comprimir. O argumento precisa ser inserido como bytes em vez de uma string.

Para velocidade de compressão média e compressão média, use o módulo bz2, adicionando import bz2. Para nossos propósitos, usaremos as seguintes funções:

• bz2.compress(), usa um argumento, que é a informação que você gostaria de comprimir.
• bz2.decompress(), usa um argumento, que é a informação que você gostaria de descomprimir. Ele precisa ser inserido como bytes em vez de uma string.

Os argumentos precisam ser inseridos como bytes em vez de uma string.

Para alta compressão, mas com velocidade de compressão lenta, use o módulo lzma, adicionando import lzma. Para nossos propósitos, usaremos as seguintes classes e funções:

• lzma.LZMACompressor(): Classe usada para criar objetos de compressão que permitem ativar um compressor.
• compress(): usa um argumento, que é a informação que você gostaria de comprimir. Ele precisa ser inserido como bytes em vez de uma string. O argumento precisa ser inserido como bytes em vez de uma string.

Além desses módulos, usaremos a função bytes(), que permite converter strings em bytes, o que será útil para a compressão. Ela recebe dois argumentos, a string que você deseja converter e o formato, que para nossos propósitos é 'utf-8'.

Existem três constantes contendo dados que precisam ser comprimidos, sendo elas nomeadas red_message, blue_message e green_message. Para começar, caminhe até o sinal X dourado sobre o tapete vermelho, crie uma variável chamada red_bytes. Pegue a constante red_message e converta a mensagem em bytes para que os dados possam ser comprimidos, usando a função bytes() formatada para 'utf-8', assim: red_bytes = bytes(red_message, 'utf-8').

Crie uma variável chamada red_compression e armazene o valor de zlib.compress(). Use red_bytes como argumento, o que irá comprimir os dados, assim: red_compression = zlib.compress(red_bytes). Uma vez que os dados foram comprimidos, use a função pré-escrita display() no editor de código e adicione as variáveis red_message e red_compression como argumentos para ler a mensagem e visualizar os dados de compressão.

Caminhe até o sinal X claro sobre o tapete vermelho e enfrente a mesa, crie duas variáveis chamadas: message_length e compression_length. Nessas variáveis, armazenaremos o comprimento em caracteres dos dados tanto antes quanto depois da compressão usando a função len(). Por exemplo, para message_length obtenha o comprimento de red_message, assim: message_length = len(red_message). Faça o mesmo para compression_length, armazenando o len() de red_compression.

Uma vez que ambas as variáveis foram populadas, use a função pré-escrita write() e insira message_length e compression_length como argumentos para verificar os tamanhos de compressão. Isso demonstra quanto o arquivo foi comprimido em relação a quando está sem compressão.

Caminhe até o sinal X escuro sobre o tapete azul, vire-se para o computador. Crie uma variável chamada blue_bytes e converta blue_message em bytes usando a função bytes() da mesma maneira que você fez com red_message. Pegue a constante blue_message e compacte-a armazenando o valor de bz2.compress() e inserindo blue_bytes como argumento para comprimir os dados, assim: blue_message = bz2.compress(blue_bytes).

Crie uma variável chamada blue_decompress e armazene o valor de bz2.decompress() e adicione blue_message como argumento para visualizar os dados após a descompressão. Adicione as variáveis blue_message e blue_decompress à função pré-escrita display() para visualizar as variantes dos dados da mensagem comprimida e descomprimida.

Caminhe até o sinal X escuro sobre o tapete verde e crie um objeto chamado compressor e o popule com lzma.LZMACompressor(), isto criará um objeto compressor que pode ser usado com as funções do lzma. Crie uma variável chamada green_bytes e transforme green_message em formato de bytes usando a função bytes() da mesma maneira que você fez com red_message e blue_message.

Crie uma variável chamada green_compression e armazene compressor.compress() como valor, adicionando green_bytes como variável. Isso permitirá que você compacte os dados da mensagem usando o objeto compressor. Na função pré-escrita display() adicione as variáveis green_message e green_compression como argumentos para visualizar a mensagem e os dados comprimidos.

Caminhe até o sinal X claro sobre o tapete verde e enfrente a mesa, modifique as duas variáveis chamadas: message_length e compression_length. Nessas variáveis, armazenaremos o comprimento em caracteres dos dados tanto antes quanto depois da compressão usando a função len(). Para message_length obtenha o comprimento de green_message com len(). Faça o mesmo para compression_length, armazenando o len() de green_compression. Uma vez que ambas as variáveis foram populadas, use a função pré-escrita write() e insira message_length e compression_length como argumentos para verificar os tamanhos de compressão e finalizar o nível.