Python para Engenheiros de Redes - Parte IV

Olá Pessoal Bom Dia, hoje vamos trabalhar com o interpretador de python em modo interativo, e na medida que irmos avançando vamos ver alguns conceitos como variavéis,funções etc.

O programa “python” encontra-se instalado geralmente em “/usr/local/bin” ou “/usr/bin” , vocês podem enviar o comando “which python” e o resultado vai lhes mostrar o caminho correto onde está o nosso interpretador,:

jose@rejane:~$ which python

/usr/bin/python

jose@rejane:~$

Na minha laptop o interpretador encontra-se em “/usr/bin”, e provavelmente na VM que vocês instalaram também.

Vocês também podem utilizar o interpretador online no próprio site do python https://www.python.org/shell/

Quando vocês entrarem lá vai lhes aparecer uma tela preta com o interpretador python versão 3, para propósitos de testes não tem problemas, porém o ideal é vocês terem instalado a VM conforme já mostrado na parte II dessa série de posts; isso porque além de aprender python também vão ir aprendendo um pouco de Linux.

Qual é a função do interpretador?, a função do interpretador é traduzir as nossa linhas de código em código executavél (0 e 1). O interpretador lê linha por linha o nosso código e o programa vai sendo utilizado na medida em que vai sendo traduzido. Toda vez que seja executado o código o mesmo será novamente traduzido.

Vamos executar o comando “python” para chamar ao interpretador na nossa VM, lembrem-se que para sair do interpretador basta teclar Ctrl-D ou exit(), também vocês podem utilizar as setas para acima ↑e para baixo ↓ do teclado, com isso o interpretador vai lhes mostrar os comandos previamente executados.

jose@rejane:~$ python

Python 2.7.6 (default, Jun 22 2015, 17:58:13)

[GCC 4.8.2] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>>

Quando você chama o interpretador dessa forma se diz que você esta utilizando o interpretador de forma interativa.

Vamos testar o interpretador com uma das funções mais conhecidas, a função “print”. Dita função serve para printar na tela, mensagens e valores de variáveis.

>>> print("Ola Mundo")

Ola Mundo

>>>

P.S De momento vamos utilizar as mensagens sem acento, em post posteriores vou lhes mostrar que os acentos da erro de encoding no momento de rodar algum script e para isso precisa setar o encoding UTF-8.

Vocês podem também printar variáveis, vamos utilizar uma variável “x” e lhe assignar um valor numérico inteiro positivo.

>>> x=11

>>>

Dá para saber o valor atual da variável “x”, teclando o nome da variável e dando enter:

>>> x=11

>>> x

11

>>>

Agora utilizamos a função “print” para printar a variável x:

>>> print("Valor da variavel x: %d" % x)

Valor da variavel x: 11

>>>

O simbolo “%d”, quer dizer que a variável que vamos imprimir é um inteiro decimal, depois vem o símbolo “%” e depois dele as variáves a serem printadas.

Agora queremos por exemplo printar o nosso número inteiro porém com 4 dígitos, caso seja um número menor a 4 dígitos completar com zeros:

>>> print("Valor da variavel x: %04d" % x)

Valor da variavel x: 0011

>>>

Nesse caso temos utilizado “%04d” que quer dizer, utiliza 4 digitos para printar, e completa com zeros caso seja necessário.

Agora vamos criar uma variável “y” e lhe dar um valor real positivo:

>>> y=5.6

7

>>> y

5.6

7

>>> print("Valor da variavel y: %f" % y)

Valor da variavel y: 5.670000

>>>

Para fazer o print da variável “y”, temos utilizado “%f”, o “f” vem de float, que significa número real. Vamos dar uma melhorada no print, vamos arredondar o número para um único dígito decimal.

>>> print("Valor da variavel y: %04.1f" % y)

Valor da variavel y: 05.7

>>>

O “%04.1f” quer dizer, printa o número com quatro dígitos (incluindo o ponto decimal), completa com zeros se necessário, e arredonda para um único decimal.

O que acontece se queremos imprimir os dois números ao mesmo tempo??

>>> print("Valor da variaveis x,y: %04d %04.1f" % (x,y))

Valor da variaveis x,y: 0011 05.7

>>>

Utilizamos os parênteses para agrupar as variáveis que vão ser printadas, separadas por coma.

Vocês devem ter percebido que em momento nenhum eu declarei o tipo de variável. Eu não coloquei no código coisas do tipo “x int”, ou “y float”; em python não se faz necessário a declaração do tipo de variável, o interpretador se encarrega automaticamente disso.

Caso queiram verificar qual tipo de variável está sendo utilizada podem executar o comando type():

>>> type(x)

<type 'int'>

>>> type(y)

<type 'float'>

>>>

Agora vamos somar as variáveis “x” e “y” e atribuir a soma a variável “z”:

>>> z=x+y

>>> z

16.67

>>> type(z)

<type 'float'>

>>>

Automaticamente o pyhton deu para “z” o tipo float. Vocês podem testar outras operações como subtração, divisão, módulo etc

E variáveis do tipo string, texto? Bom vamos testar... criemos uma variável chamada “pi” e vamos lhe dar o valor de “3.14”. Em python você pode utilizar aspas simples ou aspas duplas para criar variáveis do tipo string, a diferença é que com aspas duplas posso incluir as aspas simples dentro do string.

>>> pi="3.14"

>>> pi

'3.14'

>>> type(pi)

<type 'str'>

>>>

>>> teste="D'Alessandro Jogador do Inter"

>>> teste

"D'Alessandro Jogador do Inter"

>>>

E se quisernos saber quantos carateres tem a nossa variavél pi?, nesse caso podemos utilizar a função em python len():

>>> len(pi)

4

>>> 

Deu 4 caracteres, sendo a vírgula decimal um deles. Podemos também concatenar strings:

>>> teste="D'Alessandro Jogador do Inter"

>>> teste2=", e Renato Gaucho tecnico do Gremio"

>>> teste3=teste + teste2

>>> teste3

"D'Alessandro Jogador do Inter, e Renato Gaucho tecnico do Gremio"

>>> 

E se queremos colocar tudo em caixa alta?

>>> teste3.upper()

"D'ALESSANDRO JOGADOR DO INTER, E RENATO GAUCHO TECNICO DO GREMIO"

>>> 

Existem outras funções que se aplicam a strings, basta somente dar uma procurada na doc ou no google.

E se agora eu quero, somar mina variavél "z(float)"e "pi(string)":

>>> z+pi

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: unsupported operand type(s) for +: 'float' and 'str'

>>>

Como era de se imaginar, deu erro por ser variáveis de tipos diferentes. Porém existe um workaround, podemos fazer com que o string seja considerado númerico, no caso float, esse tipo de operação é chamada de CAST.

>>> z + float(pi)

19.810000000000002

>>>

Vamos imprimir o valor de pi:

>>> print("Valor da variaveis pi: %s" % pi)

Valor da variaveis pi: 3.14

>>>

Para imprimir string utilizamos o símbolo “%s”, s de string. 

O que acontece se eu tento imprimir o valor de “z” do tipo “float” como string:

>>> print("Variavel z: %s" %z)

Variavel z: 16.67

>>>

E se tentar o imprimir a variavél “pi” do tipo string como “float”

>>> print("Variavel z: %f" %pi)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: float argument required, not str

>>>

Interessante, podem ver que qualquer número pode ser impresso como string sem maiores problemas, existe um cast automático, porém o contrário, um string ser impresso como númerico da erro.

Vocês podem encontrar outros tipos de formatação além das %d,%f,%s em:

https://docs.python.org/2/library/stdtypes.html#string-formatting

Aqui lhes deixo um link com alguns exercícios onde podem praticar online, os tipos de variáveis e a função print.

https://www.learnpython.org/en/Variables_and_Types

O que acontece se por exemplo precisamos definir as credenciais de login para um determinado roteador, podemos fazer da seguinte forma:

>>> R1_IP="192.168.0.100"

>>> R1_user="cisco"

>>> R1_pass="cisco"

>>>

O detalhe, é que todas essas variáveis pertencem ao elemento R1, será que existe alguma forma de agrupar todos esses valores em algum tipo de variável?. A resposta é sim, e um deles são as chamadas listas. Da doc do python : "Uma lista é um conjunto ordenado de valores, onde cada valor é identificado por um índice. Os valores que compõem uma lista são chamados elementos. Listas são similares a strings, que são conjuntos ordenados de caracteres, com a diferença que os elementos de uma lista podem possuir qualquer tipo"

Vamos agrupar todas as variáveis acima em uma lista:

>>> R1=["192.168.0.100","cisco","cisco"]

>>> R1

['192.168.0.100', 'cisco', 'cisco']

>>>

Sendo que o primeiro elemento tem o index=0, o segundo 1 o terceiro 2 e assim sucessivamente, e cada valor é separado por virgula:

>>> R1[0]

'192.168.0.100'

>>> R1[1]

'cisco'

>>> R1[2]

'cisco'

>>>

Podemos, adicionar, deletar ou modificar qualquer elemento de uma lista, vejamos os exemplos abaixo:

Modificando o usuário “cisco” para “teste”:

>>> R1[1]="teste"

>>> R1

['192.168.0.100', 'teste', 'cisco']

>>>

Se eu quiser somente obter o último elemento, no caso a senha:

>>> R1[-1]

'cisco'

>>>

Adicionando um elemento à lista:

>>> R1.append("sh run")

>>> R1

['192.168.0.100', 'teste', 'cisco', 'sh run']

>>>

Se quisernos apagar um ítem da lista:

>>> del R1[3]

>>> R1

['192.168.0.100', 'teste', 'cisco']

>>>

Em listas existe uma operação chamada de slicing, fatiamento, onde podemos escolher um sub-set dos elementos que existem na lista:

A nomenclatura para escolher o subset é da forma nome_da_lista[a:b], onde “a” é o index inicial(incluindo o elemento no subset) e “b” é o index final (excluindo o elemento do subset).

No gráfico acima temos uma lista de sete elementos, porém queremos somente os elementos com index do 2 até o 5. Então vamos utilizar o slicing [2:6], index=2 que é o início, e index=6 que é o final, excluindo o elemento de index 6.

Vejamos um exemplo, a lista R1 tem 7 valores index de 0 até 6:

>>> R1

['192.168.0.100', 'teste', 'cisco', 'sh ip int bri', 'show run', 'show ver', 'show ip ospf']

>>> R1[2:6]

['cisco', 'sh ip int bri', 'show run', 'show ver']

>>>

Se eu tiver uma lista e quiser somente os elementos a partir do index=1 para frente, posso deixar em branco o valor de “b” na operação de fatiamento:

>>> R1

['192.168.0.100', 'teste', 'cisco', 'sh ip int bri']

>>> R1[1:]

['teste', 'cisco', 'sh ip int bri']

>>>

Segue um link de um blog python que mostra mais exemplos de fatiamento:

http://www.devfuria.com.br/python/sequencias-fatiamento/

Outro tipo de operação com listas é a concatenação, podemos juntar duas listas em uma só:

>>> R1

['192.168.0.100', 'teste', 'cisco', 'sh ip int bri', 'show run', 'show ver', 'show ip ospf']

>>> R2=["192.168.0.101", "teste2", "cisco2","sh ip mpls", "sh ip route"]

>>> R2

['192.168.0.101', 'teste2', 'cisco2', 'sh ip mpls', 'sh ip route']

>>>

>>>

>>> MyRouters=R1+R2

>>>

>>> MyRouters

['192.168.0.100', 'teste', 'cisco', 'sh ip int bri', 'show run', 'show ver', 'show ip ospf', '192.168.0.101', 'teste2', 'cisco2', 'sh ip mpls', 'sh ip route']

>>> len(R1)

7

>>> len(R2)

5

>>> len(MyRouters)

12

>>>

A lista MyRouters é a soma das listas R1, e R2, podemos verificar isso ao utilizar a função “len”, que nos devolve o número de elementos de uma lista.

Dica, para saber quais operações podemos executar sobre um objeto podemos utilizar o comando dir(). Exemplo:

>>> dir(R1)

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

>>>

Executei o comando dir para o objeto R1, e ele me mostra os atributos e metodos do objeto R1, no caso tenho as funções “append”, “count”, “sort”, “reverse” etc...vamos executar essa função “reverse” que se vê interessante:

>>> R1.reverse()

>>> R1

['show ip ospf', 'show ver', 'show run', 'sh ip int bri', 'cisco', 'teste', '192.168.0.100']

>>>

Legal, ele inverte a ordem dos valores na lista.

Segue o link da documentação python sobre listas, caso queiram dar uma olhada:

https://docs.python.org/2/tutorial/datastructures.html

Vamos executar o dir() para um objeto do tipo string e ver o que nos mostra:

>>> s="IOS (tm) 2500 Software (C2500-JS-L), Version 11.3(6), RELEASE SOFTWARE (fc1)"

>>> s

'IOS (tm) 2500 Software (C2500-JS-L), Version 11.3(6), RELEASE SOFTWARE (fc1)'

>>>

>>>

>>> dir(s)

['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

>>>

Temos várias funções decode, encode, join, lower etc.. No exemplo acima, o string foi obtido depois de executar o comando “show ver” num 2500, e agora precisamos separar os campos, IOS, Version e Release:

>>> s.split(",")

['IOS (tm) 2500 Software (C2500-JS-L)', ' Version 11.3(6)', ' RELEASE SOFTWARE (fc1)']

>>>

>>> Router2500=s.split(",")

>>> Router2500

['IOS (tm) 2500 Software (C2500-JS-L)', ' Version 11.3(6)', ' RELEASE SOFTWARE (fc1)']

>>> Router2500[0]

'IOS (tm) 2500 Software (C2500-JS-L)'

>>> Router2500[1]

' Version 11.3(6)'

>>> Router2500[2]

' RELEASE SOFTWARE (fc1)'

>>>

Com ajuda da função split, dividimos o string “s” tendo como separado o caracter “,” e enviamos o resultado a uma variável do tipo lista chamada “Router2500”.

Nesse post temos aprendido a utilizar o interpretador, agora sabemos que em Python não é preciso declarar o tipo de variável, e que para imprimir os valores das variáveis na tela podemos utilizar formatos específicos se precisar

Também aprendemos a utilizar variáveis do tipo inteiro, float, string ,listas, e uma das funções maiormente utilizadas que é a função “print”. Também aprendimos a usar as funções type(),dir() e len().

Existem muitas funções, operações inerentes a cada tipo de variável, e a grande maioria vamos ter sempre que procurar na documentação ou no google para saber a utilização correta, visto que é impossível saber todas de cabeça.

Por hoje é isso pessoal espero que tenham gostado, semana que vem continuamos com mais tipos de dados como dicionários, e vamos começar a ver condicionais, laços de repetição etc.

Abçs e Obrigado pela Atenção!!