17 de jan de 2018

Python para Engenheiros de Redes - Parte VI



Olá Pessoal Bom Dia, continuando com nosso curso de python hoje vamos aprender sobre laços de repetição, sentenças “for” e “while”.

Laço de Repetição “for”:
A sentença “for” é utilizada para iterar sobre uma sequência de elementos. Frequentemente utilizada quando precisamos repetir um bloco de instruções “n” vezes.

Exemplo:

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.
>>> MyRouters=['R1','R2','R3','R4']
>>> MyRouters
['R1', 'R2', 'R3', 'R4']
>>> for myrouter in MyRouters:
...  print myrouter
..
R1
R2
R3
R4
>>>

No exemplo acima temos criado uma lista com o nome de 4 routers, e temos utilizado um laço “for” para iterar sobre cada elemento da lista. A variável “myrouter” é uma variável que é criada dentro da sintaxe do laço “for” e representa um elemento da lista, ela pode ter qualquer nome.

Também posso iterar sobre uma sequência de números:

>>> for i in range(5):
...  print i
...
0
1
2
3
4
>>>

A função range(n), utilizando um único argunmento, me devolve uma sequência de números de 0,1..n-1. Vocês podem ver a doc da função range() em https://docs.python.org/3/library/stdtypes.html#range

Utilizando a função range e len, podemos iterar sobre uma lista utilizando os índices da lista por exemplo:

>>> for i in range(len(MyRouters)):
...  print MyRouters[i]
...
R1
R2
R3
R4
>>>


Vejamos agora como fazer um loop em um dicionário.

Definindo o dicionário MyRoutersDict:

>>> MyRoutersDict={'R1': '192.168.100.1','R2':'192.168.100.2','R3':'192.168.100.3','R4':'192.168.100.4'}
>>> MyRoutersDict
{'R4': '192.168.100.4', 'R1': '192.168.100.1', 'R2': '192.168.100.2', 'R3': '192.168.100.3'}
>>>

Para iterar sobre as chaves:

>>> for key in MyRoutersDict:
...  print key
...
R4
R1
R2
R3
>>>

Para iterar sobre os pares chave, valor:

>>> for key,value in MyRoutersDict.items():
...  print "Chave %s,Valor %s" % (key,value)
...
Chave R4,Valor 192.168.100.4
Chave R1,Valor 192.168.100.1
Chave R2,Valor 192.168.100.2
Chave R3,Valor 192.168.100.3
>>>

Se queremos iterar sobre os valores somente:

>>> for value in MyRoutersDict.values():
...  print value
...
192.168.100.4
192.168.100.1
192.168.100.2
192.168.100.3
>>>



Break:
Em alguns casos se faz necessário quebrar um laço quando alguma condição é alcançada:

>>> for i in range(1,20):
...  if i==4:
...   break
...  print i
...
1
2
3
>>>
No exemplo acima, é feita uma iteração de 1,2..20, porém existe uma condição dentro do laço for que diz que quando cheguemos ao valor i==4 o laço deve ser quebrado, caso contrário imprime o valor da variavél “i”.

Continue:
Existem ocasiões que vamos precisar executar um laço de repetição, pulando alguns valores da sequência de iteração.

>>> for value in MyRoutersDict.values():
...  if value=='192.168.100.2':
...   continue
...  print "Valor: %s" % value
...
Valor: 192.168.100.4
Valor: 192.168.100.1
Valor: 192.168.100.3
>>>
Do exemplo acima, quando a iteração chega no valor da chave R2 (192.168.100.2), a sentença “continue” ordena ao laço pular o código do bloco “for”, no caso o “print” para o valor da chave R2.

Pass: 
Pass em python é uma sentença nula, ela não faz nada, a única diferença entre um comentário e o pass, é que o interpretador ignora os comentários enquanto que o pass não, porém nada acontece quando um “pass” é executado.

Geralmente é utilizado quando queremos implementar um laço ou uma função no futuro, porém não temos uma idéia clara do código que deverá ser executado. Como o corpo do laço ou a função não pode ficar vazio, utilizamos uma sentença “pass”.

>>> for router in MyRouters:
...  pass
...
>>> 



Laço de Repetição While:

O laço while, serve para executar um bloco de código sempre e quando uma condição seja verdadeira. Em outra palavras “Enquanto isso seja verdadeiro, executa”.

>>> j=0
>>> while j<=10:
...  print j
...  j=j+1
...
0
1
2
3
4
5
6
7
8
9
10
Do exemplo acima temos a variável “j” setada inicialmente no valor zero, o laço While nos diz, enquanto “j” seja menor ou igual a 10, imprime o resultado e incrementa “j”. Quando “j” chega no valor de 11 a condição j<=10 não é mais satisfeita e o laço termina.

Laços de repetição aninhados (nested loops):
Muitas vezes é preciso executar um laço de repetição, que à sua vez executa um outro laço de repetição vejamos um exemplo:

Seja a lista MyRouters:

>>> MyRouters
['R1', 'R2', 'R3', 'R4']
>>>

E a lista MyCommands:


>>> MyCommands=['show ip int bri','show run','show ip ospf']
>>> MyCommands
['show ip int bri', 'show run', 'show ip ospf']
>>>


Gostaria de executar todos os comandos da lista MyCommands, para cada um dos roteadores da lista MyRouters.


>>> for router in MyRouters:
...  for command in MyCommands:
...   print "Executando comando %s em roteador %s" % (command,router)
...
Executando comando show ip int bri em roteador R1
Executando comando show run em roteador R1
Executando comando show ip ospf em roteador R1
Executando comando show ip int bri em roteador R2
Executando comando show run em roteador R2
Executando comando show ip ospf em roteador R2
Executando comando show ip int bri em roteador R3
Executando comando show run em roteador R3
Executando comando show ip ospf em roteador R3
Executando comando show ip int bri em roteador R4
Executando comando show run em roteador R4
Executando comando show ip ospf em roteador R4
>>>

Podemos ver que todos os comandos foram executados para cada um dos roteadores.

Por hoje é isso ai, no próximo post vamos tratar sobre funções.. espero que tenham gostado e estejam praticando nem que seja um pouco os conceitos aqui apresentados.

Abçs e uma ótima semana.
Jose CCIE#35681

16 de jan de 2018

Como Filtrar Rotas indesejadas ANTES delas chegarem ao Roteador de Borda


Com BGP ORF, uma prefix-list criada em seu roteador de borda pode ser enviada para sua Operadora e todo o consumo de CPU resultante da execução dos Filtros fica por conta dela.

É muito comum um Provedor solicitar Full-Route para uma Operadora mas filtrar a maioria das rotas que chegam no seu roteador de Borda, deixando muitas vezes apenas a rota padrão ser aprendida ou então apenas um determinado conjunto de rotas (Partial Route). Isso por quê pedir para a Operadora mudar o anúncio pode demorar algum tempo.

Com roteadores Cisco, é possível criar um Filtro em seu Roteador de Borda e executa-lo no roteador da Operadora. Assim, o processamento do Filtro é feito externamente e apenas as rotas desejadas chegam até sua borda. Vejamos um exemplo de configuração:

Obs: Este conteúdo é abordado no Curso Preparatório para o Exame CCIE Written 400-101

Passo 1 - Configuração Básica - Vamos assumir aqui que R1 é o roteador da Operadora e R2 é o roteador de Borda:

ena
conf t
hostname R1
int lo0
ip addr 6.6.6.6 255.255.255.255
int lo1
ip addr 200.10.1.1 255.255.255.0
int lo2
ip addr 200.10.2.1 255.255.255.0
int lo3
ip addr 200.10.3.1 255.255.255.0
int lo4
ip addr 200.10.4.1 255.255.255.0
int lo5
ip addr 200.10.5.1 255.255.255.0
int e0/0
ip addr 200.10.0.1 255.255.255.252
no shut
exit
ip route 0.0.0.0 0.0.0.0 lo0
router bgp 65001
neighbor 200.10.0.2 remote-as 65002
netw 200.10.1.0 mask 255.255.255.0
netw 200.10.2.0 mask 255.255.255.0
netw 200.10.3.0 mask 255.255.255.0
netw 200.10.4.0 mask 255.255.255.0
netw 200.10.5.0 mask 255.255.255.0
netw 0.0.0.0 mask 0.0.0.0
end
wr


ena
conf t
hostname R2
int e0/0
ip addr 200.10.0.2 255.255.255.252
no shut
exit
router bgp 65002
neighbor 200.10.0.1 remote-as 65001
end
wr

O roteador1 vai enviar 5 rotas 200.10 mais a rota padrão para o roteador2, as quais serão aprendidas, conforme a saida abaixo:

R2#sh ip route bgp

B* 0.0.0.0/0 [20/0] via 200.10.0.1, 00:00:46
B 200.10.1.0/24 [20/0] via 200.10.0.1, 00:00:46
B 200.10.2.0/24 [20/0] via 200.10.0.1, 00:00:46
B 200.10.3.0/24 [20/0] via 200.10.0.1, 00:00:46
B 200.10.4.0/24 [20/0] via 200.10.0.1, 00:00:46
B 200.10.5.0/24 [20/0] via 200.10.0.1, 00:00:46


Passo 2 - Vamos criar uma Prefix-List que só aceite o recebimento da rota padrão e descarte as demais rotas, e então vamos associar essa prefix-list
com o vizinho roteador1:

R2(config)#ip prefix-list DEFAULT-ROUTE permit 0.0.0.0/0
R2(config)#router bgp 65002
R2(config-router)#neighbor 200.10.0.1 prefix-list DEFAULT-ROUTE in

Passo 3 - Vamos forçar a atualização das rotas com o comando clear ip bgp * (mas antes vamos ativar um debug para acompanhar a execução do filtro)

R2#debug ip bgp update
BGP updates debugging is on for address family: IPv4 Unicast

R2#clear ip bgp *
R2#
*Jan 16 13:36:20.118: %BGP-5-ADJCHANGE: neighbor 200.10.0.1 Down User reset
*Jan 16 13:36:20.118: %BGP_SESSION-5-ADJCHANGE: neighbor 200.10.0.1 IPv4 Unicast topology base removed from session User reset
*Jan 16 13:36:20.464: %BGP-5-ADJCHANGE: neighbor 200.10.0.1 Up
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd UPDATE w/ attr: nexthop 200.10.0.1, origin i, metric 0, merged path 65001, AS_PATH
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 0.0.0.0/0
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.1.0/24 -- DENIED due to: distribute/prefix-list;
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.2.0/24 -- DENIED due to: distribute/prefix-list;
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.3.0/24 -- DENIED due to: distribute/prefix-list;
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.4.0/24 -- DENIED due to: distribute/prefix-list;
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.5.0/24 -- DENIED due to:
R2# distribute/prefix-list;
*Jan 16 13:36:21.483: BGP(0): Revise route installing 1 of 1 routes for 0.0.0.0/0 -> 200.10.0.1(global) to main IP table

Conforme podemos acompanhar acima, as 5 redes 200.10 recebidas foram negadas pela prefix-list e apenas o rota padrão doi instalada. Podemos confirmar isso como o comando abaixo em R2:

R2#show ip route bgp
B* 0.0.0.0/0 [20/0] via 200.10.0.1, 00:02:22

Passo 4 - Vimos que o Filtro funciona, agora, vamos configurar a feature BGP ORF (Outbound Router Filter) que permite que R2 exporte o filtro para R1 de modo que o mesmo seja executado no roteador que faz o anúncio e não naquele que recebe as rotas:

em R1
router bgp 65001
neighbor 200.10.0.2 capability orf prefix-list receive
end
wr

em R2
router bgp 65002
neighbor 200.10.0.1 capability orf prefix-list send
end
wr

Passo 5 - Verique que ao forçar novamente a atualização, apenas a rota padrão é enviada ao R2, o descarte já foi feito na origem, que recebeu a Prefix-list e a executou localmente:

R2#clear ip bgp *
R2#
*Jan 16 13:58:54.546: %BGP-5-ADJCHANGE: neighbor 200.10.0.1 Down User reset
*Jan 16 13:58:54.546: %BGP_SESSION-5-ADJCHANGE: neighbor 200.10.0.1 IPv4 Unicast topology base removed from session User reset
R2#
*Jan 16 13:58:55.576: %BGP-5-ADJCHANGE: neighbor 200.10.0.1 Up
R2#
*Jan 16 13:58:56.602: BGP(0): 200.10.0.1 rcvd UPDATE w/ attr: nexthop 200.10.0.1, origin i, metric 0, merged path 65001, AS_PATH
*Jan 16 13:58:56.602: BGP(0): 200.10.0.1 rcvd 0.0.0.0/0
R2#
*Jan 16 13:58:57.633: BGP(0): Revise route installing 1 of 1 routes for 0.0.0.0/0 -> 200.10.0.1(global) to main IP table


Limitações: BGP ORF requer que os dois lados suportem a capability, não funciona com Access-list nem com tráfego Multicast

Maiores Informações:

Outbound Route Filtering Capability for BGP-4
http://www.ietf.org/internet-drafts/draft-ietf-idr-route-filter-16.txt

BGP Prefix-Based Outbound Route Filtering
http://www.cisco.com/en/US/docs/ios/12_2t/12_2t11/feature/guide/ft11borf.html










13 de jan de 2018

Chamada para a Palestra - Tenha uma Carreira Abundante!!!



Victor Gomes, 18o. CCIE Voice e 1o. CCIE Collaboration do Brasil, estará ministrando a Palestra "Tenha uma Carreira Abundante" aqui pelo NetfindersBrasil, dia 20/01/2018, as 20:00 horas.

Inscrições pelo link abaixo:
http://netfindersbrasil.blogspot.com.br/2017/12/palestra-tenha-uma-carreira-abundante.html

Vagas Limitadas! Garanta já a sua!

11 de jan de 2018

Configuração de Switches Cisco - Lab 100% Hands-On


Curso Presencial voltado a configuração de Switches Cisco. Domine as principais caracteristicas do protocolo Ethernet.

Descrição:

Ethernet é o protocolo dominante em redes de Camada 2 já há muitos anos em ambiente LAN e a cada dia firma-se como a melhor opção em redes MAN e WAN . Este curso se propõe a realizar, de forma prática, a configuração e o Troubleshooting de Switches Cisco Ethernet de forma 100% prática.

Metodologia E-Doing (Aprenda Fazendo):

Os alunos irão construir um cenário a partir do zero, levantando todas as configurações, de modo a ter um exemplo de rede Ethernet com imagens de Switches de Camada 2 e 3, configurando todos os protocolos necessários para tornar a Rede estável e segura.

Público-Alvo: Profissionais de TI que desejam dominar os fundamentos de Redes Ethernet para prestar Exames Cisco da Carreira de Routing & Switching ou para melhorar suas capacidades de configuração e troubleshooting em Switches Cisco L2 e L3.

Local:

Rua Marquês de Itu, 408 - Conjunto 24
Vila Buarque - São Paulo - SP (Próximo a Estação República do Metrô)


Vagas Limitadas - garanta já a sua!!! Está longe de SP ? Acompanhe o curso remotamente em Tempo Real!!!

Conteúdo Programático:

Dia 01 - Configuração e Administração de um Switch Cisco
- Comandos Básicos em um Switch Cisco
- Funcionamento da tabela CAM
- Protocolos de camada 2 - CDP, LLDP e UDLD
- Criação de VLANs - portas de acesso e trunk, vlan database, tipos de VLANs
- Protocolo VTP versões 1,2 e 3 - VTP pruning, encapsulamento dot1Q, VLAN Nativa.
- EtherChannels - negociação via LACP, PAgP e configuração manual, funcionamento em camada 2 e 3, balanceamento de carga
- Protocolo Spanning Tree - PVST+, RPVST+, MST, Switch priority, port priority, path cost, STP timers
- Spanning-Tree Tool-Kit - PortFast, BPDUguard, BPDUfilter, Loopguard e Rootguard
- Captura de dados para análise com SPAN e RSPAN

Dia 02 - Infraestrutura de Serviços e Segurança
- Hardening da Caixa - Configurando senhas e desabilitando serviços desnecessários
- DHCP snooping
- IP Source Guard
- Dynamic ARP inspection
- Port security
- Troubleshoot de interfaces em Err-disable
- Private VLAN
- Storm control
- Autenticação, Autorização e Account - AAA com TACACS+ e RADIUS
- Protocolos de Redundância de primeiro salto - HSRP, VRRP e GLBP

Diferenciais:

Uso do Emulador EVE (Emulated Virtual Environment) que permite a criação de cenários Multivendor com soluções de dezenas de fabricantes. Os alunos poderão baixar e criar seu próprio servidor local, de modo a utiliza-lo para testes e homologação de cenários de Redes Reais.
120 dias de acesso a Plataforma NetFindersBrasil, onde o aluno poderá interagir via Fóruns de Aula para sanar suas dúvidas após a realização do Treinamento

Periodo:

Dias 27/01/2017 e 03/02/2017 - das 09:00 as 18:00 - com intervalo de 01 hora para almoço e coffee-breaks nos períodos da manhã e tarde

Carga Horária: 16 horas

Investimento:

R$ 590,00 - Podendo ser parcelado em até 12X via PagSeguro

Mini-Curriculum do Instrutor:

·Adilson Aparecido Florentino é Tecnólogo em Processamento de Dados pela Universidade Mackenzie e Especialista em Redes de Computadores pela FASP - Faculades Associadas de São Paulo. Atua como Instrutor Cisco desde 2001, primeiro no Programa Cisco Network Academy e atualmente como Instrutor Cisco CCSI # 33706.Possui as Certificações CCNA RS, CCNA Voice, CCNA Security, CCNA Wireless, CCDA, CCDP e CCNP RS.
·Fundador e CEO da EAMSOFT Consultoria e Treinamento em Informática Ltda. Atuou como Professor Universitário em diversas Instituições de Ensino tais como FATEC, IFSP, UNICID, FIAP e IBTA. Prestador de SErviços para o NIC.br nos cursos de IPv6 e Boas Práticas em BGP
·Autor do Livro IPv6 na Prática - primeiro livro em português sobre o tema. Consultor independente atuando em várias empresas em Projetos de Rede e treinamento utilizando roteadores Cisco, Juniper e Mikrotik

Garanta já a sua vaga comprando esta Oficina Hand-On pelo botão abaixo:








Maiores Informações pelo e-mail: adilson.aflorentino@eamsoft.com.br

10 de jan de 2018

Preparatório CCIE Written 400-101 - Fevereiro de 2018 - aos Sábados

Devido a grande procura pelo Preparatório para o Exame CCIE Written aos Sábados em 2017, o NetFindersBrasil está lançando a primeira turma aos sábados de 2018 agora em fevereiro.


O objetivo deste curso é preparar os candidatos para passar no Exame Teórico - CCIE Written - e estarem aptos a realizar o curso Bootcamp CCIE Hands-on, a ser realizado no segundo semestre de 2018. Após passarem no Exame Teórico, os candidatos renovarão todas as suas Certificações Cisco de nível CCNA e CCNP e terão 18 meses para prestar e passar no Exame Prático.

O curso ocorre na região central de São Paulo. São apenas 10 vagas, à um valor promocional de R$ 1.990,00

Os treinamentos serão ministrados aos Sábados, das 09:00hs às 18:00hs, com intervalo de 1 hora para almoço e coffee-breaks. O pagamento pode ser parcelado no Cartão de Crédito via PagSeguro.

Os participantes contarão também com acesso a Laboratórios similares aos Cobrados no Exame CCIE, de forma a já se ambientarem com o ritmo e o conteúdo cobrado no Exame Prático

◦Quando:

Preparatório CCIE Written 400-101 - dias 24/02, 03/03, 10/03, 17/03, 24/03, 31/03, 07/04 e 14/04, sempre das 09:00hs às 18:00hs

Conteúdo Programático: 64 horas - 8 encontros de 8 horas cada:

Aula 01 - LAN Switching
Aula 02 - IP Networking
Aula 03 - IP IGP Routing
Aula 04 - IP BGP Routing
Aula 05 - QoS & WAN
Aula 06 - IP Multicast & Security
Aula 07 - MPLS
Aula 08 - Evolving Technologies

◦Onde:

Rua Marquês de Itu, 408 - Conjunto 24 (próximo a Estação República do Metrô)

◦Investimento: R$ 1.990,00 (Podendo ser parcelado no Cartão de Crédito via PagSeguro).

◦Carga Horária: 64 horas presenciais.

◦Diferenciais: Os alunos terão acesso, desde o momento em que sua matrícula for confirmada, um ambiente criado no Servidor Moodle do netfindersbrasil.com.br contendo uma série de materiais para que os alunos se preparem para os Exames Teórico e Prático, sendo que os Fóruns de Dúvidas de cada Aula estarão disponíveis

Solicite informações sobre as inscrições pelo e-mail: adilson.aflorentino@eamsoft.com.br

Python para Engenheiros de Redes - Parte V



Olá Pessoal Bom Dia, depois de uma breve pausa por festas de final de ano, vamos continuar com nosso curso de introdução à programação Python.

Hoje continuaremos falando dos tipos de dados que existem em python e sobre a condicional “if”, que é uma das sentenças utilizadas para controlar o fluxo do nosso programa.

No post anterior, conhecemos o que são as listas, as quais servem para agrupar uma série de valores em uma única variavél. Existe um tipo de dado que tem uma função similar chamado de dicionário, os dicionários são estruturas de dados que permitem armazenar um conjunto não organizado de pares do tipo Key-Value (Chave-Valor), sendo as chaves únicas dentro de um mesmo dicionário.

Vejamos um exemplo para esclarecimento, vamos armazenar os valores de ip, usuário e senha para dois roteadores R1 e R2:


>>> R1={'ip':"192.168.0.100",'user':"cisco",'senha':"cisco123"}
>>> R1
{'ip': '192.168.0.100', 'user': 'cisco', 'senha': 'cisco123'}
>>> R2={'ip':"192.168.0.101",'user':"cisco2",'senha':"cisco456"}
>>> R2
{'ip': '192.168.0.101', 'user': 'cisco2', 'senha': 'cisco456'}
>>>

Do exemplo acima podemos ver que um dicionário é definido entre chaves {}, e que cada elemento dentro do dicionário é separado por vírgula. Para a definição dos pares chave-valor é utilizado o símbolo “:”

Sendo assim temos o elemento dicionário R1, contém os seguintes pares chave:valor

'ip':"192.168.0.100"
'user':"cisco"
'senha':"cisco123"

A chave pode ser númerica também, no caso eu utilizei uma chave do tipo string.

Vejamos alguns métodos que é possível executar nos dicionários:

O número de elementos do dicionário:

>>> numElemR1 = len(R1)
>>> numElemR1
3
>>>

As chaves do dicionário:

>>> keys=R1.keys()
>>> keys
['ip', 'user', 'senha']


Os valores do dicionário:

>>> values=R1.values()
>>> values
['192.168.0.100', 'cisco', 'cisco123']
>>>

Acessando um elemento em particular do dicionário utilizando o valor da chave:

>>> R1_ipaddress=R1['ip']
>>> R1_ipaddress
'192.168.0.100'
>>>


Adicionando um par chave: valor no dicionário, no exemplo o par "command:show run" :

>>> R1.setdefault('command','show run')
'show run'
>>> R1
{'ip': '192.168.0.100', 'command': 'show run', 'user': 'cisco', 'senha': 'cisco123'}
>>>


Modificando o valor,

>>> R1['command']="show ip int bri"
>>> R1
{'ip': '192.168.0.100', 'command': 'show ip int bri', 'user': 'cisco', 'senha': 'cisco123'}
>>>


Eliminando um elemento do dicionário utilizando “pop”:

>>> R1.pop('command')
'show run'
>>> R1
{'ip': '192.168.0.100', 'user': 'cisco', 'senha': 'cisco123'}
>>>



Scripting:

Até agora temos trabalhado com o interpretador de python de forma interativa, porém existe uma outra forma que é a mais utilizada, e com a qual vamos trabalhar a grande maioria do tempo, é a chamada forma de “script”.

Basicamente vamos colocar o nosso código em um arquivo texto de extensão “*.py” e chamar o interpretador para que o código seja executado. Eu chamei o script de "meuprimeiroscript.py".


Do exemplo acima a primeira linha “#!/usr/bin/python” sinaliza qual é o interpretador que vamos utilizar no caso o python, a terceira linha que começa com o símbolo “#”, é um comentário. O interpretador irá descartar essa linhas, porém para nós eles ajudam bastante no momento de ler o código.

Executemos o nosso primeiro script, não esqueçam de dar permissão de execução ao seu arquivo via comando “chmod”.





Pronto!! Acabamos de executar o nosso primeiro script python!.


Indentação:
Em outras linguagens de programação, blocos de instrução como if, for, while, iniciam e finalizam com chaves {}. Em python existe o conceito de “indentação”, que não é outra coisa que um espaçamento do texto em referência à margem esquerda vejamos um exemplo:




Do exemplo acima a primeira linha vermelha começando pelo lado esquerdo, não tem espaços vazios, então ela tem indentação=0, e todas as linhas de código que tenham indentação =0 farão parte de um bloco de instruções, depois da linha “if x==1”, tem um primeiro espaço, é dizer indentação=1, fazem parte desse bloco as linhas “print(“X=1”) e “if y==2”; por último depois do “if y==2” vem mais um espaço vazio, o que da indentação=2 , a linha “print(“X=1 e Y=2”) faz parte desse bloco de instrução. Finalizado o bloco de indentação=2, voltamos à indentação=0 onde a linha “print(“Feliz Natal”) será executada.

A indentação em python é similar aos {} em outras linguagens, por exemplo um código similar em php:


$x=1;
$y=2;
if ($x==1) {
 echo "$x";
 if ($y==2) {
  echo "$x,$y";
 }
}

Em php, são as chaves que indicam os blocos de instruções.

Podemos ver que a profundidade da indentação ajuda a definir os blocos de instruções. A indentação é de vital importância em python, o mau uso dela, acarreta geralmente em errors de interpretação, vejamos alguns exemplos:



Quando rodamos o exemplo acima obtemos o seguinte erro:




O erro é devido ao fato que o interpretador espera depois da linha “print(“X=1”)”, uma linha de código na mesma profundidade de indentação do print, isso porque o print não é um comando que inicia um bloco de execução, como if, while, for, with etc.

Vejamos outro exemplo:



Ao executar o código acima temos:




O erro dessa vez acontece, porque depois do “if y==2”, o interpretador python espera mais um nível de indentação, porém em vez disso temos o “print(“X=1 e Y+2”)” no mesmo nível.

Como regra geral, toda vez que precisem utilizar algum bloco if, while, for with etc adicionem mais um nível de indentação, em outras palavras adicionem mais um espaço vazio.



Controle de Fluxo:

Condicional “if”:

if condição:
 linha1
 linha2
….

A sentença “if”, é utilizada caso queira se executar um bloco de instruções se uma certa condição/condições é/são verdadeiras.

Para avaliar se uma “condição” é verdadeira ou não, geralmente é utilizada uma série de operadores que podem ser de comparação , lógicos, booleanos etc. Nesse link https://www.tutorialspoint.com/python/python_basic_operators.htm podem encontrar todos os operadores que existem em python.

Exemplo utilizando “if” com operador de comparação igual “==”:

x=10

if x==10:
 print(“X=10”)


O código acima vai printar a mensagem “X=10” sempre e quando a condição de igualdade “x==10” seja verdadeira. Se trocarnos o valor de x, para qualquer outro valor diferente de 10, a condição vai ser falsa e o print não será executado:

Outro exemplo utilizando o operador booleano “and”


x=1
y=2

if x==1 and y==2 :
 print(“X=1 e Y=2”)

No exemplo acima, para que o print seja executado, é preciso que as duas condições sejam verdadeiras tanto “x==1” como “y==2”.

Utilizando o operador “or”


x=1
y=3

if x==1 or y==2 :
 print(“X=1 ou Y=2”)


Trocamos o valor de “y” para y=3. A condição “x==1” continua sendo verdadeira , porém a condição “y==2” agora é falsa. Como estamos utilizando o operador “or”, basta uma das condições ser verdadeira, no caso “x==1”, para o print ser executado, se rodar o código acima a mensagem do print será exibida na tela.


Condicional “if..else”:

if condição:
 linha1
 linha2
 …
else:
 linha3
 linha4


A condição “if..else”, serve para quando queremos executar código, caso a condição que estamos avaliando, de como resultado falso.


R1=['192.168.0.100','cisco','cisco123','show ip ospf']

if 'ospf' in R1[3]:
 print(“Vamos executar um comando ospf em R1”)
else:
 print(“O roteador R1, nao contem comandos ospf a serem executados”)


Do exemplo acima, se a palavra “ospf” existe no elemento da lista R1[3], é executado o print indicando que existe um comando ospf, caso contrário, um print indicando que não existem comandos ospfs em R1 é executado.

Condicional “if..elif..elif..else”


if condição:
 linha1
 linha2
elif condição:
 linha3
 linha4
elif condição:
 linha5
 linha6
else:
 linha7
 linha8


As vezes é preciso executar blocos de instruções, para um determinado número de condições:

Exemplo


x=10

if x<10:
 print(“X <10”)
elif x>10:
 print(“X >10”)
else:
 print(“X=10”)


No código acima, estamos avaliando duas condições, se “x>10” e se “x<10”, e caso nenhuma das condições acima seja cumprida, então quer dizer que “x=10”

Por hoje é isso, espero que tenham gostado do post, eu sei que para nós engenheiros de redes as vezes nos resulta um pouco tedioso aprender a programar, porém acreditem depois de aprenderem um novo mundo de possibilidades será aberto...










5 de jan de 2018

CCNA 200-125 - Curso Presencial em SP - Fevereiro de 2018


Uma excelente oportunidade para aqueles que residem na cidade de São Paulo e região, estão abertas as inscrições para o Preparatório CCNA 200-125 em fevereiro de 2018. Vagas Limitadas!!!

O curso ocorre em São Paulo - Capital. São apenas 10 vagas, à um valor promocional de R$ 1.590,00

O curso será ministrado de segunda a sexta, das 09:00hs às 18:00hs, com intervalo de 1 hora para almoço e coffee-breaks. O pagamento pode ser parcelado em até 12x via PagSeguro.

◦Carga Horária: 40 horas

◦Quando: dias 05/02, 06/02, 07/02, 08/02 e 09/02, sempre das 09:00hs às 18:00hs

◦Onde: Rua Marquês de Itu, 408 - Conjunto 24 - Vila Buarque - São Paulo - SP (próximo a Estação República do Metrô)

◦Quanto: R$ 1.590,00 (Podendo ser parcelado em até 12X via PagSeguro)

◦Diferenciais
: Incluso no valor do investimento acesso ao Curso CCNA Routing & Switching em Modo Gravado via ambiente Portal de Treinamentos NetFindersBrasil (o acesso é liberado logo após a confirmação do pagamento do curso e se estende por 120 dias após o término do curso presencial).

Conteúdo Programático:


Aula 01
Introdução as Carreiras Cisco
Apresentando o Exame 200-120
Modelo de referência ISO-OSI
O modelo de referência TCP/IP
Switching e VLANs
Configuração de Switches (Security, VLANs, Etherchannel)

Aula 02
Endereçamento IPv4
Subredes
Variable Lenght Subnet Masks (VLSM)
Classless Interdomain Routing (CIDR)
IPv6
Subredes IPv6

Aula 03
O sistema operacional Cisco IOS
O processo de licenciamento do IOS 15
Apresentação do Cisco Configuration Professional (CCP)
Gerenciamento básico de uma rede
Autenticação local de usuários
SNMPv2 e v3
Cisco Netflow
Syslog
Listas de Controle de Acesso (ACLs)

Aula 04
O processo de roteamento IP
Roteamento IP Estático
Roteamento IP dinâmico (RIPv1 e RIPv2)
Roteamento IP dinâmico – EIGRP
Roteamento IP dinâmico – OSPF multi-area
Sumarização de rotas (configuração)
Roteamento IPv6 estático
Roteamento IPv6 dinâmico – RIPng
Roteamento IPv6 dinâmico -OSPFv3
Roteamento IPv6 dinâmico – EIGRP

Aula 05
Protocolos WAN (HDLC / PPP / PPPoE / Metro Ethernet e MPLS)
Conceitos de QoS
First Hop Redundancy Protocols (HSRP, VRRP e GLBP)
Prática de Cenários para o exame: Laboratórios

◦IMPORTANTE: Os alunos deverão trazer notebook para a realização dos laboratórios utilizando o EVE-ng.

Os interessados devem enviar e-mail solicitando instruções para matricula para:

adilson.aflorentino@eamsoft.com.br

◦Inscrições por tempo limitado. São apenas 10 vagas. Garanta já a sua !!!

28 de dez de 2017

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:






11 de dez de 2017

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:



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


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:



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

LinkWithin

Related Posts with Thumbnails