Empacotando e descompactando em Python

Packing é uma ferramenta Python útil que fornece uma maneira dinâmica de empacotar e descompactar valores em uma única estrutura de dados ou retirá-los e atribuí-los a múltiplas variáveis. Este processo melhora muito a confiabilidade e adaptabilidade do seu código.

Em Python, “empacotamento” refere-se ao processo de colocar valores em uma nova tupla ou lista, separando-os com vírgulas. Isso pode ser feito com uma instrução de atribuição onde o lado esquerdo é uma tupla ou lista de variáveis ​​e o lado direito é outra tupla ou lista de valores.

Por exemplo, você pode ter três variáveis, que são número1, número2 e número3, que são definidas como tal:

number1 = 1
number2 = 2
number3 = 3

Você pode empacotar essas variáveis ​​em uma tupla assim:

myTup = (number1, number2, number3)

Ou uma lista como esta:

myList = (number1, number2, number3)

Você também pode usar o *operador (que é usado como operadores de potência e de multiplicação). Antes de vermos como isso funciona com a embalagem, deixe-me mostrar como o *operador funciona. Definiremos uma função chamada sumOf e usaremos o * operador assim:

def sumOf(*nums):
    print('Our numbers are:', nums)
    return sum(nums)
print('Adding them up, we get:', sumOf(10, 20, 30))

Saiba disso *números armazena a série de números e então a função sum() os soma. Então, quando executado, a saída acima seria:

Our numbers are: (10, 20, 30)
Adding them up, we get: 60

Voltando à embalagem, podemos usar o * operador com embalagem assim:

num1=1
num2=2
num3=3
*num,=num1,num2,num3

Mas como usamos o empacotamento no código Python real?

Embalagem com tuplas

Lembre-se de que uma tupla é uma lista imutável, portanto não pode ser alterada depois de criada. Tuplas são ótimas opções para armazenar dados que você não deseja modificar. Digamos que queremos criar um programa simples, usando tuplas e empacotamento para somar uma sequência de números. Definiremos nossa função personalizada como tal:

addPack(*myTuple):
     return sum(myTuple)

Acima, estamos enviando um número dinâmico de argumentos para a função addPack e acessando-os por meio de um único parâmetro myTuple usando o * operador.

A seguir, empacotamos nossos argumentos com as duas linhas a seguir:

print(addPack(2, 3, 4, 5, 6, 7, 8))
print(addPack(5, 10, 15, 20))

Como estamos usando argumentos dinâmicos para empacotamento, poderíamos ter continuado com nossos números assim:

print(addPack(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
print(addPack(5, 10, 15, 20, 25, 30, 35, 40))

Quando executamos o aplicativo, ele soma os números em ambas as tuplas e os totaliza. O que isso fez foi embalar o addPack função com variáveis ​​das funções de impressão.

Você também pode coletar vários valores com embalagem e usar determinadas peças de maneiras diferentes. Veja, por exemplo, este trecho de código Python:

name="John Jacob Jinglheimer Schmidt"
first_name, *rest_name=name.split()
print("Complete Name:", name)
print("First Name Only:", first_name)
print("Remaining names:", rest_name)

O procedimento acima executa o que é chamado de divisão de string para coletar apenas o primeiro nome de alguém com vários nomes. O que isso faz é coletar o primeiro nome em uma variável e os nomes restantes em outra (daí a divisão da string).

A saída do exemplo de embalagem acima seria:

Complete Name: John Jacob Jinglheimer Schmidt
First Name Only: John
Remaining names: ('Jacob', 'Jinglheimer', 'Schmidt')

Descompactando com tuplas

Em Python, descompactar é o processo de extrair valores de uma sequência e atribuí-los a múltiplas variáveis. Conseguimos descompactar com o operador de atribuição no lado esquerdo e um objeto iterável no lado esquerdo.

Por exemplo, podemos descompactar com uma tupla assim:

myTuple = (1, 2, 3)
a, b, c = myTuple
print(myTuple)

A saída acima seria:

(1, 2, 3)

Outro exemplo de descompactação de uma tupla é assim:

fruits = ("apple", "banana", "cherry")
(green, yellow, red) = fruits

print(green)
print(yellow)
print(red)

O que fizemos foi atribuir valores a múltiplas variáveis ​​e depois descompactá-las. A saída do script acima seria:

apple
banana
cherry

Podemos descompactar uma lista como esta:

myList = (10, 20, 30)
a, b, c = myList
print(myList)

A saída acima seria:

(10, 20, 30)

Também podemos descompactar dicionários (uma coleção não ordenada de dados no formato de um par chave-valor) da seguinte forma:

myDict = {'fname': 'Jack', 'lname': 'Wallen', 'country': 'USA'}
fname, name, country = myDict.values()
print(myDict.values())

A saída do script acima seria:

dict_values(('Jack', 'Wallen', 'USA'))

A descompactação permite atribuir valores de uma sequência a múltiplas variáveis, usando apenas uma única linha de código.

Ao usar empacotamento e descompactação você pode criar atribuições com uma única instrução e capturar vários valores com um único identificador, tornando assim seu código muito mais fácil de ler. Esses dois recursos permitem um manuseio muito mais flexível de argumentos de função e uma manipulação simplificada de dados.

O post Empacotando e descompactando em Python apareceu pela primeira vez em The New Stack.