Palestra: Tenha uma Carreira Abundante!

Está instatisfeito com seu trabalho? Anda acordando desmotivado? Está estressado brigando com a mulher , o vizinho e o cachorro? Saiba que você pode ter o emprego que desejar e ter uma vida/carreira abundante. Dia 20/01/2018 (sábado)- das 20:00 as 22:00 horas - Palestra Motivacional com o CCIE Victor Gomes.

Após a grande procura por parte dos leitores do Blog NetFindersBrasil pelo sorteio das sessões de Coaching e Mentoring doadas pelo Victor Gomes, nosso ilustre CCIE resolveu fazer uma palestra aberta ao público para auxiliar aqueles que procuram construir um carreira Cisco bem sucedida e, mais importante que isso, alcançar a Felicidade no trabalho em que realiza.

Mini-Curriculum: Victor Gomes - CCIE Voice #41440, CCNP, CCIP e CCNP Voice , CCIE Security Written, com 10 (dez) anos de experiência nas áreas de redes de grande porte e execução de projetos complexos, como reestruturação de Backbone e implementação de MPLS.

Victor Gomes também é formado e membro da sociedade latino americana de Coach (SLAC - Credenciamento de coach internacional), líder e referência nacional e internacional em treinamentos e soluções de alta performance.

Como Participar ? Garanta já a sua vaga, por apenas R$ 50,00 - São apenas 30 vagas destinadas ao evento online - Adquira a sua no botão abaixo:

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!!