Objetivo

Receber mensagens e pedidos e compactá-los para arquivamento e transmissão.

Existem várias instruções de construção, remessas e manifestos que foram enviados e precisam ser transferidos ou arquivados. Embora seja possível enviá-los manualmente, uma boa forma de fazer isso é compactar e descompactar arquivos antes de armazená-los ou enviá-los. Para isso, você pode usar módulos de compressão para reduzir o tamanho dos arquivos e facilitar o gerenciamento das informações. Diferentemente de outros problemas que resolvemos, em que aprendemos e usamos um único módulo, existem vários módulos de compressão que podemos usar com um pequeno conjunto de funções. Eles são os seguintes:

Para velocidade de compressão rápida e compactação baixa, use o módulo zlib, adicionando import zlib. Para nossos propósitos, usaremos a seguinte função: zlib.compress(), que utiliza um argumento, que é a informação que deseja compactar. O argumento precisa ser fornecido em bytes em vez de string.

Para velocidade de compressão média e compactaçã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 deseja compactar.
• bz2.decompress(), usa um argumento, que é a informação que deseja descompactar. Precisa ser fornecido em bytes em vez de string.

Os argumentos precisam ser fornecidos em bytes em vez de string.

Para alta compressão, mas velocidade lenta de compressão, 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 deseja compactar. Precisa ser fornecido em bytes em vez de string.

Além desses módulos, usaremos a função bytes(), que permite converter strings em bytes, o que é útil para 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 compactados, chamadas red_message, blue_message e green_message. Para começar, vá até o X dourado sobre o tapete vermelho e crie uma variável chamada red_bytes. Pegue a constante red_message e converta a mensagem em bytes para que os dados possam ser compactados, usando a função bytes() com formato '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 para compactar os dados, assim: red_compression = zlib.compress(red_bytes). Depois que os dados forem compactados, 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.

Vá até o X claro sobre o tapete vermelho e posicione-se de frente para a mesa. Crie duas variáveis chamadas message_length e compression_length. Nelas, vamos armazenar o comprimento em caracteres dos dados antes e 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.

Depois que ambas as variáveis forem atribuídas, 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 o quanto o arquivo fica compactado em relação ao estado sem compactação.

Vá até o X escuro sobre o tapete azul e posicione-se de frente para o computador. Crie uma variável chamada blue_bytes e converta blue_message em bytes usando a função bytes() da mesma forma que fez com red_message. Pegue a constante blue_message e compacte-a armazenando o valor de bz2.compress() e passando blue_bytes como argumento para compactar os dados, assim: blue_message = bz2.compress(blue_bytes).

Crie uma variável chamada blue_decompress e armazene o valor de bz2.decompress(), passando blue_message como argumento para visualizar os dados após a descompressão. Adicione as variáveis blue_message e blue _decompress na função pré-escrita display() para ver as versões compactada e descompactada dos dados da mensagem.

Siga até o X escuro sobre o tapete verde e crie um objeto chamado compressor, inicializando-o com lzma.LZMACompressor(). Isso 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 bytes usando a função bytes() da mesma forma que fez com red_message e blue message.

Crie uma variável chamada green_compression e atribua compressor.compress() como valor, passando green_bytes como argumento. Isso permitirá compactar 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 compactados.

Vá até o X claro sobre o tapete verde e posicione-se de frente para a mesa. Modifique as duas variáveis chamadas message_length e compression_length. Nelas, vamos armazenar o comprimento em caracteres dos dados antes e 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. Depois que ambas as variáveis estiverem atribuídas, use a função pré-escrita write() e insira message_length e compression_length como argumentos para verificar os tamanhos de compressão e concluir o nível.