Maratona Python para Automação de Rede #3: Trabalhando com List, Dictionary e Tuple

Buenas NetCode… Neste artigo iremos dar os primeiros passos em listas, dicionários e tuplas no Python.

iremos desmistificar o conceito por trás destas estruturas de dados que mapeiam elementos dentro de si. Estas definições de estrutura de dados, de certa forma, pode nos ajudar a montar uma estrutura poderosa de automação.

Neste artigo você aprenderá a trabalhar múltiplas estruturas de dados na linguagem Python, compreendendo como devem ser feitas as declarações e atribuições de elementos para manipular dentro destas estruturas. Pegue seu café e vamos nessa!

Tópicos

• List
  • Múltiplos dados contidos numa estrutura de listas
  • Manipulando dados contidos numa lista
  • Declarando o parâmetro for
• Dictionary
  • Manipulando dados contidos dentro de um dicionário
• Tuple

List

Quando falamos de lista, ao definir uma variável para ser estruturada do tipo lista, podemos definir da seguinte forma:

>>> hostnames = ["R1, R2, R3"]
>>> print(hostnames)
['R1, R2, R3']
>>>
>>> type(hostnames)
<class 'list'>
>>>

Definimos uma variável hostnames e abrimos dois colchetes [ ], dentro destes colchetes, definimos um elemento. Descrevemos que só há um elemento pelo fato de quem tem apenas uma aspas duplas abrindo a inserção deste elemento e outra aspas duplas fechando a inserção deste elemento.

No código abaixo iremos definir as aspas duplas em cada hostname para especificar que cada um dos hostnames se refere à um elemento inserido dentro da lista:

>>> hostnames = ["R1", "R2", "R3"]
>>> print(hostnames)
['R1', 'R2', 'R3']
>>> 
>>> len(hostnames)
3
>>>

Dica: A função len() lê e imprime a quantidade de elementos contidos dentro de uma lista.

Múltiplos dados contidos numa estrutura de listas

A lista é um tipo de estrutura de dados muito relevante para casos onde são contidos diversos formatos de dados para que sejam manipulados durante a varredura de um código:

>>> hostnames = ["R1", "R2", "R3", True]
>>> print(hostnames[3])
True
>>> 
>>> type(hostnames[3]) # Imprimindo o tipo de dado
<class 'bool'>
>>> 
>>> hostnames = ["R1", "R2", "R3", True, 10]
>>> print(hostnames[4])
10
>>> 
>>> type(hostnames[4]) # Imprimindo o tipo de dado
<class 'int'>
>>>

Para ficar ainda mais interessante, podemos definir sub listas, ou seja, inserir uma lista dentro de outra lista, segue um exemplo mostrado abaixo:

>>> hostnames = ["R1", "R2", "R3", True, 10, ["S3", "S2"]]
>>> print(hostnames)
['R1', 'R2', 'R3', True, 10, ['S3', 'S2']]
>>> 
>>> type(hostnames)
<class 'list'>
>>> 
>>> type(hostnames[4])
<class 'int'>
>>> 
>>> type(hostnames[5]) # Imprimindo o tipo de dado 
<class 'list'>
>>>

Percebe-se que ao executar o parâmetro type(hostnames[5]) foi retornado que este item se baseia numa lista? Pois, essa lista está alocada dentro de uma lista primária.

Manipulando dados contidos numa lista

Quando falamos em manipular dados dentro de uma lista, nos referimos à diversas possibilidades de fazer alterações ou varreduras dos elementos pertencentes à uma lista.

Abaixo é mostrado um exemplo de como fazer a alteração de um elemento específico sem que declarássemos a variável do tipo lista por completo:

>>> hostnames[0] = "RT01"
>>> 
>>> print(hostnames)
['RT10', 'R2', 'R3', True, 10, ['S1', 'S2', 'S3']]
>>>

Declarando o parâmetro for

No código descrito abaixo, definimos uma variável associada à uma lista onde contém três IP sendo 3 elementos no formato string pelo fato de estar sob aspas.

Depois definimos uma outra variável contendo um valor inteiro.

À parte destas duas variáveis, foi definido um loop, o loop você define através do parâmetro for seguido de :.

O parâmetro for serve para fazermos uma varredura da lista. Dentro da estrutura do for, declaramos que queríamos definir o loop para a variável ip_address.

Dentro deste loop, declaramos a variável router_num seguido de uma soma e armazenamos o valor 1. Ou seja, vai ser somado o valor 0 + 1. Definimos desta forma, pois, ao executar uma lista, o Python sempre executa o elemento -1.

Na função print(), a variável router_num passa a ser alocada no primeiro bloco de chaves e é representada pela soma declarada na variável.

A variável router passa a ser alocada no segundo bloco de chaves e é representada pelos elementos dentro da variável ip_address associada à uma lista e que foi convertida para variável router dentro do loop.

>>> IP = ["192.168.10.1", "192.168.20.1", "192.168.30.1"]
>>> router_num = 0

>>> for router in IP:
...     router_num +=1
...	    print("O IP do R{} é: {} ".format(router_num, router))

O IP do R1 é: 192.168.10.1 
O IP do R2 é: 192.168.20.1 
O IP do R3 é: 192.168.30.1
>>>

Percebe-se que cada rodada deste for ele vai interagindo com os valores armazenados dentro das duas variáveis. Ou seja, ele acaba fazendo a varredura dos elementos contidos lista e anexando-os em cada { } alocadas dentro do print().

Dictionary

Quando definimos uma variável para ser dicionário, associamos uma chave, e dentro desta chave atribuímos um valor. Na lista, isto não é possível fazer, pois, a lista você define valores específicos para representar o mesmo valor específico.

Numa estrutura de dicionário podemos definir um elemento para representar um valor, é como se fosse uma variável armazenando valores.

No exemplo descrito abaixo, se refere em elementos que consiste em par entre chave e valor:

>>> ipAddress = {"R1":"10.0.0.1", "R2":"10.0.0.2"}
>>> type(ipAddress)
<class 'dict'>
>>>

O dicionário é um tipo de estrutura muito mais viável para armazenar sub elementos e buscar este sub elemento dentro do código. No exemplo abaixo é mostrado a forma de listar um dos valores (elementos) contidos dentro de uma chave (elementos):

>>> ipAddress["R1"]
'10.0.0.1'
>>>

Percebe-se que no exemplo acima, buscamos o valor contido dentro da chave listando apenas a chave?

Pois bem, a forma de estrutura de dicionário do Python permite fazer o uso da manipulação dos elementos apenas inserindo a chave, o valor é armazenado dentro dessa chave.

Agora iremos atribuir mais valores dentro de uma chave:

>>> ipAddress = {"R1":"10.0.0.1","R2": ["10.0.0.2", "10.1.1.1"]}
>>> ipAddress
{'R1': '10.0.0.1', 'R2': ['10.0.0.2', '10.1.1.1']}
>>>
>>> ipAddress["R2"]
['10.0.0.2', '10.1.1.1']
>>> 

Repare que, quando indexamos o R2, foi retornado os endereços que fazem parte deste router. No comando inserido abaixo, percebe-se que iremos buscar um valor específico dentro de uma chave (R2) específica:

>>> ipAddress["R2"][0]
'10.0.0.2'
>>>

É desta forma que manipulamos valores dentro das chaves.

No dicionário Python podemos utilizar três principais métodos:

• .items()
• .keys()
• .values()

.items(): Com este método podemos listar os itens que contém dentro do dicionário:

>>> ipAddress.items()
dict_items([('R1', '10.0.0.1'), ('R2', ['10.0.0.2', '10.1.1.1'])])
>>> 
>>> type(ipAddress.items())
<class 'dict_items'>
>>>

Convertendo o dicionário em lista e listando o primeiro item desta lista:

>>> list(ipAddress.items())
[('R1', '10.0.0.1'), ('R2', ['10.0.0.2', '10.1.1.1'])]
>>> 
>>> list(ipAddress.items())[0]
('R1', '10.0.0.1')
>>>

.keys(): - Este método nos permite visualizar as chaves que estão presentes no dicionario:

>> ipAddress.keys()
dict_keys(['R1', 'R2'])
>>>

.values(): - Este método nos permite visualizar os valores que contém dentro das chaves:

>>> ipAddress.values()
dict_values(['10.0.0.1', ['10.0.0.2', '10.1.1.1']])
>>>

Manipulando dados contidos dentro de um dicionário

Em listas, já vimos como varrer elementos, agora veremos como manipular elementos dentro de um dicionário, já que no dicionário iremos manipular elementos baseados em chave e valor. Na lista não é possível fazer esta manipulação, apenas manipula valores fixos.

Neste exemplo abaixo, definimos uma variável dicionário e atribuímos chaves e valores a esta variável.

Em seguida, abrimos uma varredura utilizando o parâmetro for para fazer o loop destes elementos.

Dentro do processo de loop, definimos duas variáveis fruit e quantity para manipularmos chaves e valores.

a variável fruit vem primeiro no processo de criação do loop, então ela representará as chaves dentro do dicionário.

A variável quantity vem em segundo no processo de criação do loop, então ela representará os valores dentro do dicionário.

Ao definir como será printado, definimos para primeiro printar a quantidade seguido dos itens:

fruits = {'apple': 5, 'banana': 6, 'orange': 4}
for fruit, quantity in fruits.items():
  print("Voce possuí {} {}. ".format(quantity, fruit))

Resultado do código descrito acima:

Executing...
Checking dependencies
Voce possuí 5 apple. 
Voce possuí 6 banana. 
Voce possuí 4 orange.

Tuple

O que diferencia a tupla do dicionário e lista é que, quando você insere um valor dentro de uma tupla, você não consegue alterá-lo, ou seja, é outro tipo de estrutura de dados que é apenas utilizado na leitura de dados que são fixos:

>>> teste = (1, "3")
>>> type(teste)
<class 'tuple'>
>>>
>>> teste[0]
1
>>> teste[1]
'3'
>>>

Na tupla você consegue indexar e representar diversos elementos como nas outras estruturas de dados. A tupla é como se fosse um cache armazenado em memória, serve para dar performance dependendo dos dados que você está trabalhando.

Usando estes conceitos desde o início deste capítulo, que conseguimos trabalhar e estruturar dados JSON em Python pelo fato de que a representatividade de dados que o JSON utiliza é chave e valor.

Onde eu consigo ter essa mesma representatividade de dados utilizando o Python? No dicionário.

Bom, por hoje é só, galerinha. E aí, o que achou deste artigo? Comente aqui embaixo, vai ser legal contar com sua presença por aqui.