VERSÃO

2025 MATERIAL DIDÁTICO COMPLETO

MÓDULO 15
PYTHON
DO ZERO ABSOLUTO

“Não tenham medo da vida, por favor! Tenham medo da morte, da

morte da alma, da morte do futuro, do fechamento do coração. Disto
vocês devem ter medo. Mas da vida não, a vida é bela.”

Papa Francisco

@ProfessorJoaoAntonio

https://professorjoaoantonio.com.br
Apresentação do Autor
Olá, querido leitor, estimada leitora,

Meu nome é João Antonio e sou professor de informática desde 1996. Já ensinei a mais de 500 mil alunos no
Brasil e no exterior, como Portugal e Angola.

Neste documento, eu explico a linguagem de Programação Python e conceitos de lógica de programação, ideais
para responder as questões das provas de Concursos onde estes temas são importantes, mas também busco
ensinar, por meio desta apostila, a você a realmente programar de forma prática!!

Estamos utilizando, aqui, a versão 3.13 (Fevereiro de 2025) do Python.

Aqui estão meus contatos:

https://www.facebook.com/ProfessorJoaoAntonio

https://www.youtube.com/ProfessorJoaoAntonio

https://www.instagram.com/ProfessorJoaoAntonio

https://t.me/ProfessorJoaoAntonio
https://t.me/CanalJoaoAntonio (meu canal no Telegram)

[email protected]

https://professorjoaoantonio.com.br (meu site com meus cursos)

Este documento foi atualizado em 11/03/2025 12:50:00

Sumário
1. Introdução ao Ambiente do Python ..................................................................................................................................... 9
1.1. O que é Python? .......................................................................................................................................................................................9
1.2. Como Usar o Python? .............................................................................................................................................................................9
1.3. Vamos Exercitar? ................................................................................................................................................................................. 11
2. O Editor de Código ...................................................................................................................................................................12
2.1. Conhecendo o Editor de Código ....................................................................................................................................................... 12
2.2. Nosso Primeiro Código ....................................................................................................................................................................... 13
2.3. Outros Editores de Código ................................................................................................................................................................. 14
2.4. Vamos Exercitar esta Lição? ............................................................................................................................................................ 15
3. A Função print()........................................................................................................................................................................16
3.1. Vamos nos conhecer melhor? .......................................................................................................................................................... 16
3.2. Como Usar a Função print()? ............................................................................................................................................................ 16
3.3. Função print() com mais de um Parâmetro.................................................................................................................................. 18
3.4. Vamos Exercitar? ................................................................................................................................................................................. 20
4. Tipos de Dados no Python .....................................................................................................................................................21
4.1. Por que "Tipos" de Dados? ................................................................................................................................................................. 21
4.2. Vamos Exercitar? ................................................................................................................................................................................. 24
5. Cálculos e Mais Cálculos .......................................................................................................................................................25
5.1. Revendo os Operadores Aritméticos .............................................................................................................................................. 25
5.2. Prioridades na Frente! ........................................................................................................................................................................ 26
5.3. Vamos Exercitar? ................................................................................................................................................................................. 28
6. Variáveis......................................................................................................................................................................................29
6.1. O que são Variáveis? ........................................................................................................................................................................... 29
6.2. Criando uma Variável .......................................................................................................................................................................... 29
6.3. Usando Variáveis .................................................................................................................................................................................. 30
6.4. Chegou a Hora de Exercitar .............................................................................................................................................................. 35
7. Comentários e Textos Longos .............................................................................................................................................36
7.1. Comentários e Erros – Programa de Exemplo ............................................................................................................................ 36
7.2. Vamos Exercitar a Lição 7................................................................................................................................................................. 38
8. Tipo de Dados Booleano (Falso / Verdadeiro) ...............................................................................................................39
8.1. O que é Booleano?................................................................................................................................................................................ 39
8.2. Comparação com Textos .................................................................................................................................................................... 40
8.3. Vamos Exercitar? ................................................................................................................................................................................. 41
9. Algumas Funções Built-in (Já Existentes) ......................................................................................................................42
9.1. O Que são Funções? ............................................................................................................................................................................ 42
9.2. Funções de Conversão de Dados ..................................................................................................................................................... 42
9.3. Funções Numéricas Gerais ............................................................................................................................................................... 43
9.4. Vamos Exercitar sobre a Lição 9..................................................................................................................................................... 44
10. Recebendo Dados do Usuário ..............................................................................................................................................45
Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 3
 10.1. A Função de Entrada de Dados – input( ) ...................................................................................................................................... 45
10.2. Vamos Exercitar esta Lição? ............................................................................................................................................................ 46
11. Listas ............................................................................................................................................................................................48
11.1. O que são listas? ................................................................................................................................................................................... 48
11.2. O comando del ...................................................................................................................................................................................... 51
11.3. O Teste de Pertencimento in ............................................................................................................................................................. 52
11.4. Vamos Exercitar a Lição 11 .............................................................................................................................................................. 52
12. Vamos Exercitar Mais? ...........................................................................................................................................................54
12.1. Programa para Preencher uma Lista com 5 Nomes ................................................................................................................. 54
12.2. Programa para Juntar e Calcular 5 Números .............................................................................................................................. 55
12.3. Programa para Juntar 6 Nomes e 6 Idades: ................................................................................................................................. 56
13. Mais Sobre Listas .....................................................................................................................................................................57
13.1. Lista e Muitos Tipos ............................................................................................................................................................................. 57
13.2. Listas de Listas ..................................................................................................................................................................................... 57
13.3. A função list( ) ....................................................................................................................................................................................... 58
13.4. Esvaziar uma Lista .............................................................................................................................................................................. 58
13.5. Vamos Exercitar? ................................................................................................................................................................................. 59
14. A Função range( ) ....................................................................................................................................................................60
14.1. Conhecendo a função range ( )......................................................................................................................................................... 60
14.2. "A Cara" da Função range( ) ............................................................................................................................................................. 60
14.3. Vamos Exercitar? ................................................................................................................................................................................. 61
15. Brincando mais com Listas e Strings ................................................................................................................................62
15.1. Um pouco mais sobre índices .......................................................................................................................................................... 62
15.2. Slices (Fatias) ....................................................................................................................................................................................... 62
15.3. Listas são Mutáveis, Strings são Imutáveis ................................................................................................................................. 64
15.4. Vamos Exercitar? ................................................................................................................................................................................. 65
16. Tuplas ...........................................................................................................................................................................................66
16.1. Sobre o que já sabemos... .................................................................................................................................................................. 66
16.2. Conhecendo as Tuplas ........................................................................................................................................................................ 66
16.3. Como Criar uma Tupla vazia? ........................................................................................................................................................... 66
16.4. O que podemos Fazer com Tuplas, então? .................................................................................................................................... 67
16.5. Vamos Exercitar Tuplas ..................................................................................................................................................................... 68
17. Semelhanças entre Tuplas e Listas ...................................................................................................................................69
17.1. O Porquê desta Lição .......................................................................................................................................................................... 69
17.2. Semelhanças entre Tuplas e Listas ................................................................................................................................................ 69
17.3. Vamos Exercitar? ................................................................................................................................................................................. 72
18. Dictionaries (Dicionários) ......................................................................................................................................................73
18.1. Pequena Apresentação ....................................................................................................................................................................... 73
18.2. Criando Dicionários ............................................................................................................................................................................. 73
18.3. Alterando Valores dos Itens num Dicionário ................................................................................................................................ 73
18.4. Criando um Novo Elemento no Dicionário .................................................................................................................................... 74

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 4

 18.5. Apagando Elementos do Dicionário ................................................................................................................................................ 74
18.6. Chaves Duplicadas? ............................................................................................................................................................................. 74
18.7. Para que servem os Dicionários? .................................................................................................................................................... 75
18.8. Vamos Exercitar? ................................................................................................................................................................................. 75
19. A Estrutura de Repetição for ...............................................................................................................................................76
19.1. Pra que serve e Como usar a for? ................................................................................................................................................... 76
19.2. Usando o laço for com Listas ........................................................................................................................................................... 78
19.3. Vamos Exercitar? ................................................................................................................................................................................. 78
20. A Estrutura de Repetição while ..........................................................................................................................................79
20.1. Conhecendo o Laço while .................................................................................................................................................................. 79
20.2. Loop Infinito ........................................................................................................................................................................................... 80
20.3. A cláusula else ...................................................................................................................................................................................... 80
20.4. while True ............................................................................................................................................................................................... 81
20.5. Diferenças Cruciais entre for e while ............................................................................................................................................. 81
20.6. Vamos Exercitar o Laço while? ........................................................................................................................................................ 82
21. Estrutura Condicional if .........................................................................................................................................................83
21.1. Conceitos básicos do if ....................................................................................................................................................................... 83
21.2. Cláusula else ......................................................................................................................................................................................... 84
21.3. Cláusula elif ........................................................................................................................................................................................... 84
21.4. Vamos Exercitar o if? .......................................................................................................................................................................... 85
22. Caracteres Especiais nas Strings .......................................................................................................................................86
22.1. Por que Caracteres Especiais? ........................................................................................................................................................ 86
22.2. Aspas Triplas ......................................................................................................................................................................................... 87
22.3. Vamos Exercitar a Lição? .................................................................................................................................................................. 88
23. Formatando Texto ....................................................................................................................................................................89
23.1. Uma Nova Forma de Concatenar Textos e Variáveis ................................................................................................................. 89
23.2. Textos Formatados – Concatenar Strings e Variáveis .............................................................................................................. 89
23.3. Vamos exercitar?.................................................................................................................................................................................. 91
24. Muitos Programas para Estudar! ........................................................................................................................................92
24.1. Descreva quais as saídas (na tela) para os Programas a seguir: .......................................................................................... 92
24.2. Escreva um programa que… .............................................................................................................................................................. 92
25. Construindo Nossas Próprias Funções.............................................................................................................................94
25.1. Construindo Funções com Argumentos ........................................................................................................................................ 95
25.2. Vamos Exercitar esta Lição? ............................................................................................................................................................ 97
26. As Variáveis Dentro das Funções .......................................................................................................................................98
26.1. Analisando o "Escopo" de uma Variável ........................................................................................................................................ 98
26.2. O Valor Padrão de uma Variável ...................................................................................................................................................... 98
26.3. Vamos Exercitar? ............................................................................................................................................................................... 100
27. Funções Retornando Valores ............................................................................................................................................ 101
27.1. Funções podem Trazer Resultados ............................................................................................................................................... 101
27.2. Função Retornando Mais de Um Valor ......................................................................................................................................... 102

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 5

 27.3. Que Tal Exercitar a Lição? ............................................................................................................................................................... 104
28. List Comprehensions ........................................................................................................................................................... 105
28.1. O que são as List Comprehensions? ............................................................................................................................................. 105
28.2. Vamos Exercitar List Comprehensions? ..................................................................................................................................... 107
29. Mais Segredos com while .................................................................................................................................................. 108
29.1. Voltando ao Loop Infinito.................................................................................................................................................................. 108
29.2. Vamos Exercitar? ............................................................................................................................................................................... 111
30. Tratamento de Erros no Python ....................................................................................................................................... 112
30.1. O laço try .............................................................................................................................................................................................. 113
30.2. Vamos exercitar?................................................................................................................................................................................ 114
31. Usando Módulos no Python ............................................................................................................................................... 116
31.1. O que São Módulos? .......................................................................................................................................................................... 116
31.2. Importando apenas Componentes Específicos .......................................................................................................................... 117
31.3. Vamos Exercitar Módulos? .............................................................................................................................................................. 117
32. Operadores Booleanos and e or ...................................................................................................................................... 119
32.1. O que são Operadores Booleanos? ............................................................................................................................................... 119
32.2. O Operador and ................................................................................................................................................................................... 119
32.3. O Operador or ...................................................................................................................................................................................... 120
32.4. Vamos Exercitar? ............................................................................................................................................................................... 121
33. Lista de Tuplas com o Comando zip ............................................................................................................................... 122
33.1. Voltando às Listas .............................................................................................................................................................................. 122
33.2. A função zip ......................................................................................................................................................................................... 122
33.3. Mais de Duas Listas Unidas? Sim! ................................................................................................................................................ 123
33.4. Vamos Exercitar? ............................................................................................................................................................................... 124
34. Laços de Repetição Aninhados (Nested Loops) ......................................................................................................... 125
34.1. Laço for e Laço while ........................................................................................................................................................................ 125
34.2. Laço for dentro de Laço for (exemplos) ...................................................................................................................................... 125
34.3. Laço while dentro de Laço while ................................................................................................................................................... 126
34.4. Vamos Exercitar? ............................................................................................................................................................................... 128
35. Separando e Juntando Strings ......................................................................................................................................... 129
35.1. Separando Strings em Pedaços ..................................................................................................................................................... 129
35.2. Juntando uma Lista de Strings em uma Única String ............................................................................................................. 130
35.3. Vamos Exercitar ................................................................................................................................................................................. 131
36. Mais Edição de Strings ........................................................................................................................................................ 132
36.1. Métodos de Maiúsculas e Minúsculas .......................................................................................................................................... 132
36.2. Localizando Caracteres numa String ........................................................................................................................................... 132
36.3. Substituindo Caracteres de uma String ....................................................................................................................................... 133
36.4. Limpando Strings com .strip() ........................................................................................................................................................ 134
36.5. Exercitando .......................................................................................................................................................................................... 134
37. Mexendo com Números Aleatórios ................................................................................................................................. 135
37.1. Lembrando Módulos .......................................................................................................................................................................... 135

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 6

 37.2. Módulo random ................................................................................................................................................................................... 136
37.3. Exercitando Números Aleatórios................................................................................................................................................... 137
38. Usando o Módulo decimal .................................................................................................................................................. 138
38.1. Float – Problemas Curiosos ............................................................................................................................................................ 138
38.2. O módulo decimal............................................................................................................................................................................... 138
38.3. Vamos Exercitar? ............................................................................................................................................................................... 138
39. Mais sobre Dicionários ........................................................................................................................................................ 139
39.1. Recordando Dicionários ................................................................................................................................................................... 139
39.2. Dicionários e Tipos de Dados .......................................................................................................................................................... 139
39.3. Adicionando Múltiplos Dados a um Dicionário .......................................................................................................................... 139
39.4. List Comprehensions, Zip e Dicionários... Dá Match? .............................................................................................................. 140
39.5. Buscando Dados com Chaves Inválidas ...................................................................................................................................... 141
39.6. Apagando uma Entrada do Dicionário .......................................................................................................................................... 141
39.7. Listando Todas as Chaves num Dicionário ................................................................................................................................. 142
39.8. Listando Todos os Valores num Dicionário ................................................................................................................................ 143
39.9. Listando Todas as Entradas (Chave, Valor) num Dicionário .................................................................................................. 143
39.10. Vamos Exercitar Dicionários?.................................................................................................................................................... 144
40. Trabalhando com Arquivos de Texto .............................................................................................................................. 145
40.1. Por que Arquivos? .............................................................................................................................................................................. 145
40.2. A função open()................................................................................................................................................................................... 145
40.3. Iterando um Arquivo Linha por Linha ........................................................................................................................................... 146
40.4. Lendo Apenas UMA Linha do Arquivo .......................................................................................................................................... 147
40.5. Escrevendo (Salvando Dados em um) Arquivo ......................................................................................................................... 147
40.6. Vamos Exercitar? ............................................................................................................................................................................... 149
41. Trabalhando com Arquivos CSV....................................................................................................................................... 150
41.1. Arquivos CSV (Valores Separados por Vírgulas) ...................................................................................................................... 150
41.2. O Módulo csv e Suas Funções ........................................................................................................................................................ 150
41.3. E se o CSV tiver Outro Separador (Não a Vírgula) ................................................................................................................... 152
41.4. Escrevendo Dados em um Arquivo CSV ...................................................................................................................................... 153
41.5. Usando Listas em vez de Dicionários .......................................................................................................................................... 154
41.6. Resumindo o Trabalho com CSV .................................................................................................................................................... 156
41.7. Vamos exercitar? O Bicho vai Pegar! ........................................................................................................................................... 158
42. Trabalhando com Arquivos JSON .................................................................................................................................... 159
42.1. O que é JSON?..................................................................................................................................................................................... 159
42.2. Lendo um arquivo JSON .................................................................................................................................................................. 159
42.3. Escrevendo um arquivo JSON ........................................................................................................................................................ 159
42.4. Arquivos JSON com Mais de Um Registro.................................................................................................................................. 160
43. O Anaconda: o Python “Turbinado” para Ciência de Dados ..................................................................................... 164
43.1. O que é o Anaconda? ......................................................................................................................................................................... 164
43.2. Baixando o Anaconda ........................................................................................................................................................................ 164
43.3. Instalando o Anaconda...................................................................................................................................................................... 165
43.4. O que o Anaconda Contém? E Onde ele Está? ............................................................................................................................ 167

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 7

44. Outros Ambientes de Programação Python ................................................................................................................ 170
44.1. Visual Studio Code ............................................................................................................................................................................. 170
44.2. Google Colab ........................................................................................................................................................................................ 170
44.3. PyCharm – IDE Profissional para Python .................................................................................................................................... 170

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 8

1. Introdução ao Ambiente do Python
1.1. O que é Python?
Python é uma linguagem de programação de alto nível.

Linguagem de Programação: conjunto de códigos, palavras especiais e regras que nos permite criar programas
de computador (aplicativos e sites da internet, por exemplo).

Alto nível: significa que ela é bem próxima da nossa linguagem (da linguagem humana), portanto, é mais agradável
de aprender e entender!

Python é usada para muitas coisas, como programação de sites (ou seja, fazer páginas da web), análise de dados,
computação científica e inteligência artificial. Python é muito fácil de aprender e muito poderosa. Usaremos aqui,
neste material, a versão 3.13 (pode ser que você esteja usando uma versão mais atual: não tem problema!)

Como é que se
"fala" o nome
Python, João?

Que bom que perguntou, meu amigo. O nome da linguagem se fala normalmente "Páiton" ou "Páisson" (esse "ss"
é falado com a língua entre os dentes se você quiser "dar uma de bonzão, diferentão, bonitão que fala inglês com
sotaque perfeito").

1.2. Como Usar o Python?

O programa onde podemos treinar e usar a linguagem Python é chamado de IDLE1 (que é a sigla em
inglês para Ambiente de Aprendizado e Desenvolvimento Integrado). Ele é composto por uma janela
principal chamada Shell. O ícone para abrir o IDLE do Python é mostrado aqui ao lado.

Você também pode acionar o Python a partir do Menu Iniciar, no Windows (caso você
use o Windows), como visto aqui ao lado. O ícone do IDLE se encontra dentro do grupo
Python 3.132.

A janela do Shell do IDLE do Python sendo mostrada ao lado. Esta é a

primeira coisa que você verá quando abrir o IDLE do Python.

A parte mais importante desta janela é chamada de Prompt (ou "aviso"). É justamente aquele sinal de três "setas"
(>>>) que aparece para esperar os seus comandos.

1
Chamamos de IDE (Ambiente de Desenvolvimento Integrado) o conjunto de programas de computador que nos permitirá escrever nossos códigos em
Python e testá-los. Vamos usar muito este IDLE que vem junto com o Python, mas também aprenderemos a usar outros ao longo deste curso.
2
Você pode estar usando uma versão diferente do Python, portanto, os nomes podem ser diferentes daqueles mostrados neste texto. Eu uso a versão 3.13
para este documento.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 9

 Neste exemplo, eu digitei print(12+18) e pressionei ENTER. O Shell respondeu
mostrando o resultado (saída) da operação matemática – o 30 – e depois mostrou
novamente o prompt para esperar o meu próximo comando.

Então, você percebeu que no Shell é assim:

[A] O Shell do Python mostra o prompt pra você.

[B] Você digita um comando e pressiona ENTER;

[C] O Shell do Python obedece ao seu comando (e às vezes mostra saída na tela);

[D] O Shell do Python mostra o prompt novamente, esperando o seu próximo comando.

O Shell do Python é um ambiente Interativo, porque ele interage com você, ou seja, ele responde a você, usuário,
quando você está "dando as ordens".

E por que esse tal de "print()" que você

escreveu aí, João? Eu não poderia
simplesmente escrever 12+18 no prompt?

Sim, meu amigo! No prompt, você pode escrever diretamente a expressão matemática desejada, sem precisar
usar o print(), e o Shell vai responder normalmente. Veja na imagem abaixo:

Veja algumas das formas de você solicitar que o Shell do Python mostre
dados: sejam eles números, sejam textos ou resultados de cálculos
matemáticos.

Lembre-se de que sempre é necessário pressionar a tecla ENTER para

confirmar o comando para o Shell responder!

Vamos explicar a imagem da página anterior de forma bem clara agora:

[A] Não é necessário usar a função print no Shell para mostrar resultados – você pode escrever diretamente o
que deseja e o Shell vai mostrar.

[B] Se você pede que o Shell mostre textos, eles devem ser escritos entre aspas (simples ou duplas, tanto faz),
ou seja, "assim" ou 'assim';

[C] Se você pede que o Shell mostre números ou resultados de cálculos, eles não podem ser escritos entre
aspas (pois seriam entendidos como textos).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 10

1.3. Vamos Exercitar?

Usando o Shell do Python, escreva comandos para mostrar

O seu nome

>>>

A sua idade

>>>

O resultado da soma da sua idade com o número 30

>>>

O resultado da soma da sua idade com o resultado do comando anterior

>>>

O nome da cidade onde você nasceu

>>>

O que vai ser mostrado no shell do Python para cada comando a seguir:

>>> print("João Antonio")

>>> print(80 + 90)

>>> 8+10

>>> print("30+20")

Bora aprender mais coisa? Telegram e Instagram: @ProfessorJoaoAntonio

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 11

2. O Editor de Código
2.1. Conhecendo o Editor de Código
O Shell é a janela principal do IDLE do Python (isso você já sabia porque aprendemos na aula anterior).

Mas o Shell não é a única janela do programa. Existe uma outra janela que usaremos bastante chamada Editor
de Código (ou simplesmente Editor).

Você pode abrir várias janelas do Editor enquanto estiver trabalhando no IDLE. Para abrir uma nova janela do
Editor do Python, você aciona o menu File (ou Arquivo) no menu superior e, dentro dele, aciona New File (Novo
Arquivo, em português).

Para abrir uma nova janela do Editor, acione a opção New File que aparece dentro do menu
File.

CTRL+N é a tecla de atalho que aciona essa ação.

O Editor parece uma coisa bem sem-graça: é uma janela toda em branco, apenas com o menu lá em cima e o
cursor piscando, pronto para você digitar com ele.

Um exemplo de janela do Editor de Código.

A palavra untitled ("Sem Título" traduzido para o português) lá

em cima é o nome que aparece quando o conteúdo da janela
ainda não foi salvo.

Lembre-se sempre de salvar constantemente (CTRL+S) o que

você escrever aqui no Editor de Código, ok?

O Editor não é interativo como o Shell. O Editor não obedece a você na hora. Ele não responde imediatamente
aos seus comandos. Você vai escrever no Editor os seus programas – os seus scripts – e só depois você mandará
o Python obedecer a tudo.

Programa: é uma sequência de comandos que o programador escreve e que o computador obedece exatamente
em ordem – de uma vez só.

No Shell, cada comando é obedecido quando você pressiona ENTER – um por vez – manualmente. Num programa,
você escreve todos eles e depois manda que sejam obedecidos de uma vez só.

A imagem a seguir mostra um exemplo de um código escrito na linguagem Python dentro na janela do Editor.
Perceba que o editor é "esperto" e consegue colorir certas palavras e expressões especiais com cores distintas.
Você vai se acostumar com isso.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 12

 Pequeno código de programação em Python escrito na janela do Editor. Note a
presença da função "print" lá embaixo. Sim, aqui no Editor nós a usaremos muito!

Note lá em cima a palavra *Untitled* entre asteriscos. Isso indica que o conteúdo
da janela foi modificado, mas ainda não foi salvo. NUNCA SE ESQUEÇA DE
SALVAR!

2.2. Nosso Primeiro Código

Para começar nossa aventura com o Editor, vamos escrever algumas linhas de comando usando a função print.
Que tal essas aqui:

Nesta janela do Editor, escrevemos dois comandos usando a função

print (um em cada linha do código).

Cada um deles é escrito em uma linha diferente. É só pressionar ENTER

para descer para a próxima linha.

As cores foram dadas pelo próprio editor (esperto, não?): ele identifica
texto com a cor verde e print, que é uma palavra interna da linguagem,
na cor roxa – essas cores podem mudar de janela para janela!

O próximo passo é salvar o nosso código (para poder usarmos depois, se quisermos).

Ei, João, eu queria ver esse código sendo

obedecido pelo computador! Como eu faço
isso? Como se chama essa ação?

Caro amigo, a ação de fazer o computador obedecer ao nosso código é chamada de executar o programa ou
rodar o programa ("rodar" porque os programas antigamente eram gravados em fitas que giravam: você não é
dessa época e isso é só uma curiosidade).

No inglês, o verbo é "run", que quer dizer "correr", portanto, run a program significa "correr o programa" ou
"rodar o programa" ou "executar o programa" ou, finalmente, "fazer o programa funcionar".

Porém, antes de executar o programa para ver o computador obedecendo a ele, temos que salvar o nosso código
(o IDLE do Python não deixa você rodar o programa sem tê-lo salvo e você vai perceber isso da pior maneira: vai
ficar de saco cheio de tantos lembretes!).

Acione, lá em cima, no menu superior, a opção File (Arquivo) e clique em Save (Salvar). É possível usar, também,
o atalho CTRL+S. Confira na imagem.

Comando Save (Salvar), dentro do menu File (Arquivo) que também pode ser
acionado pela combinação de teclas CTRL+S.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 13

Logo em seguida, você terá de colocar um nome do arquivo que está criando. Esse arquivo terá o nome que você
quiser seguido da extensão .py.

Salvando o nosso código como galt.py

Depois disso, poderá ser normalmente executado (ou seja, nós

vamos poder ver ele funcionando).

Para executar este programa, ou seja, fazê-lo funcionar, basta acionar o comando Run Module (Executar Módulo)
que está dentro do menu superior Run (Executar). Outra forma de executar este comando é pela tecla de atalho
F5.

Comando Run Module, dentro do menu Run. Ele pode ser acionado
também pela tecla F5.

Todo programa é executado (ou seja, funciona) numa janela do Shell. Programas são construídos na janela do
Editor, mas são executados na janela do Shell. Olha só o resultado deste nosso exemplo na figura a seguir:

Janela do Shell do Python mostrando o resultado do programa que

executamos. Cada comando print que foi usado escreve sua mensagem em
uma linha diferente.

Por isso apareceram apenas duas linhas: o texto Quem é John Galt? e o
número 42.

Esta é a saída do programa, ou também chamada de resposta do programa (que é aquilo que o programa foi
construído para mostrar ao usuário).

Então é isso! Por hoje é só revisar para você não esquecer que:

[A] Você escreve os programas em Python numa Janela do Editor.

[B] Você precisa salvar o código (que também pode ser chamado de script) Python num arquivo com
extensão .py.

[C] Quando você executa o código (manda ele "trabalhar"), ele é executado (e mostra sua saída, se houver
saída) numa janela do Shell do IDLE Python.

2.3. Outros Editores de Código

Você não é obrigado a usar o editor de código que vem junto com o Python. Ele é muito básico! Há muitos outros
editores de código melhores e com mais recursos que podem te ajudar a programar de forma mais eficiente.

Um destes editores é o Sublime Text, que pode ser usado para escrever códigos em diversas linguagens de
programação, inclusive em Python.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 14

 Um pequeno exemplo de código Python escrito no Sublime Text.

Note que o Sublime Text também apresenta as palavras especiais no Python

em cores diferentes, além de mostrar o número das linhas de texto na
lateral.

Também é possível usar IDEs (Ambientes de Desenvolvimento Integrado) completos, não somente editores de
texto. Um destes ambientes completos que podem ser instalados em paralelo com o Python é o PyCharm.

Trecho da janela do PyCharm com um código em

Python sendo editado.

O PyCharm é um ambiente completo de programação

em Python que oferece editor de códigos e Shell
próprios (diferentes dos que fazem parte do IDLE do
Python)

Não se preocupe em usar qualquer editor ou ambiente – todos funcionarão igualmente, inclusive o ambiente do
próprio Python, por mais simples que ele seja.

O que importa é que você vai aprender a linguagem. O ambiente que você escolherá dependerá unicamente de
você!

2.4. Vamos Exercitar esta Lição?

Quais os resultados da execução dos códigos a seguir?

print("Qual a resposta para a vida, o universo e tudo mais?")

print(20+22)

print("É Sério! Nós calculamos!")

print("Qual a resposta do cálculo abaixo:")

print("80 + 12")

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 15

3. A Função print()
3.1. Vamos nos conhecer melhor?
Desde a primeira lição, estamos usando a função print(). Ela é simplesmente a função que faz a saída dos dados
na tela. Essa é a explicação que você verá em todos os livros de Python: "print() é a função que faz a saída dos
dados".

Eu, porém, acho melhor explicar (como sempre faço) da maneira mais clara e mais "para crianças" possível.
Espero que você não se sinta constrangido com isso. Em primeiro lugar, é bom explicar que você não é o usuário!
Você é o programador. Você é O CARA! Você é a entidade cósmica superior que está criando um programa que
será usado por um usuário.

Usuário: é a criatura nefasta que Deus colocou na tua vida para expiar os teus pecados por toda a eternidade! E
o pior: você vai se acostumar a amá-lo e odiá-lo!

Sabe qual é a diferença entre um vírus de computador e um usuário? O Vírus funciona!

Bom, acontece que o seu trabalho é criar um programa – um aplicativo ou um jogo, talvez – que será usado por
um ou mais usuários! E em muitos momentos o seu programa terá que "mostrar" coisas ao usuário, como
mensagens, avisos, nomes, números, resultados de cálculos, entre outras coisas...E é justamente aí que a função
print() trabalha!

É a função print() que usamos para colocar dados, mensagens, avisos, números e tudo mais na tela. Aquilo
que o usuário vai ver quando estiver usando o programa é resultado de uma função print(). Por isso a função
print() é a função que faz a saída de dados: ela faz os dados saírem (na tela) para que o usuário os veja!

Ô, João, por que ficar chamando de

"Função"? O que é uma Função? Não
posso chamar de "comando print()"?

Poder, até pode, nerd... quem sou eu pra te impedir, né? Mas o nome certo é função, mesmo! print() é uma função
básica na linguagem Python. Veremos isso mais tarde!

3.2. Como Usar a Função print()?

Acredito que você já está "cansado" de saber como usá-la, mas vamos aqui fazer uma lista bem objetiva e,
acredito, completa. De uma forma bem simples, a função print() é usada assim:

print(aquilo que você quer mostrar para o usuário).

Na verdade, toda função – não somente a print() – se escreve do mesmo jeito: nome(argumentos). Onde nome é
o nome da função em si e argumentos são as informações de que a função precisa para trabalhar.

Ou seja, você coloca, dentro dos parênteses, os parâmetros (ou argumentos) da função, ou seja, as informações
que a função print() vai mostrar, já que o trabalho dela é mostrar na tela.

A função print() é uma das funções Built-In3 do Python. Ou seja, é uma das funções que já vêm junto com o
próprio Python, sem precisar ser trazida ou construída posteriormente. Ela "já vem de fábrica" com a linguagem
Python.

Com a função print(), você pode mostrar muitos tipos diferentes de informações, como textos, números e
resultados de expressões (como cálculos matemáticos).

3
A expressão Built-In pode ser traduzida como "já vem construída dentro de...". Ou seja, uma função Built-In é uma função que já vem fabricada junto com
a própria linguagem Python: é parte integrante dela.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 16

Usando print() com textos

Para mostrar textos na tela para o usuário, é só colocar o texto desejado dentro dos parênteses da função entre
aspas (simples ou duplas) e ele será colocado exatamente daquele jeito na tela (as aspas não aparecerão para o
usuário – elas indicam apenas que aquilo é texto). Esquecer as aspas vai dar problema! Se liga!

Exemplos de uso da função print() com textos no Shell do Python. O resultado

é o mesmo se a função for usada numa janela do Editor.

Perceba o erro que aconteceu pelo fato de eu ter esquecido de colocar aspas
na expressão "John M. Keynes".

Não esqueça: se é texto, tem que escrever entre aspas (simples ou duplas).

Usando print() com Números e Cálculos

A função print() pode ser usada com números e cálculos (expressões matemáticas) bastando informar, dentro
dos parênteses, o que deseja mostrar, sem aspas.

Note, ao lado, alguns exemplos de impressão (saída na tela) de números e resultados de

cálculos simples. Lembre-se de que no Shell diretamente não é preciso usar a função print()
para mostrar resultados, mas estamos nos acostumando a usá-la porque no Editor, ela é
obrigatória.

Podemos aproveitar o momento de apresentações e já mostrar alguns dos principais cálculos que podemos fazer
no Python:

[A] Para somar, use o símbolo de + (mais), como em print(80+30) – isso dá 110.

[B] Para subtrair, use o símbolo de – (menos), como em print(20-12) – isso dá 8.

[C] Para multiplicar, use o símbolo de * (asterisco), como em print(4*3) – isso dá 12.

[D] Para dividir, use o símbolo de / (barra), como em print(18/6) – isso dá 3.0.

[E] Para elevar um número a uma potência, use ** (duplo asterisco), como em print(2**3) – isso significa 23,
ou seja, dá 8.

Nas próximas lições, vamos ser apresentados a uma variedade maior de símbolos que fazem cálculos (esses
símbolos são chamados de operadores matemáticos).

Números e outros valores são chamados de operandos. Sinais que realizam os cálculos, como os que vimos
acima, são chamados de operadores. Então, operador é quem realiza a operação e operando é quem sofre
(recebe) a operação.

Então, na expressão 3 + 4, dizemos que 3 e 4 são operandos e o + é o operador.

E só mais um lembrete importante: não importa se há espaços entre os operadores e operandos num cálculo. Ou
seja, se você escreve 3+4 ou 3 + 4 ou 3 + 4, não faz diferença – todos darão o mesmo resultado.

Cálculos com Textos

Muita gente pensa que não dá para fazer "cálculos" com textos... mas dá! No Python, especialmente, podemos
usar dois operadores diretamente com textos: o sinal de + e o sinal de *. Ou seja, podemos "somar" e "multiplicar"
textos. Que tal?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 17

 Note o efeito do uso dos sinais de adição (+) e multiplicação (*) em textos. Você vai usar
isso mais do que imagina!

Note, mais uma vez, que, para o Python, não importa se você escreve textos "assim" ou se
escreve-os 'assim'... tanto faz usar aspas duplas ou aspas simples.

Explicando: quando usado com textos, o sinal de + (adição) passa a realizar uma concatenação – ou seja, o sinal
de + concatena textos.

Concatenar: é o mesmo que fundir, ou unir, ou juntar textos. Transforma dois ou mais textos em um só – "tudo
junto e misturado".

Lembre-se que o resultado da concatenação é "tudo junto" mesmo! Note que o comando print("Bom"+'dia'), na
primeira linha, resultou em Bomdia (sem espaço entre as palavras). Se você quer colocar um espaço para a coisa
ficar organizada, coloque-o dentro das aspas: ou depois de "Bom " ou antes de " dia".

Eu fiz isso lá em cima no terceiro comando: print("Bom " + "dia")

Ao usar o operador de multiplicação * (asterisco), entre um número a um texto, você simplesmente dá ordem
para o Python repetir aquele texto.

Ou seja, o comando print("Então é Natal... " * 9) vai exibir:

Então é Natal... Então é Natal... Então é Natal... Então é Natal... Então é Natal... Então é Natal... Então é Natal...
Então é Natal... Então é Natal...

(Ninguém merece... na voz da cantora Simone... não tem como não lembrar)

Aqui vai um Alerta: quando usados em textos, há certas exigências para os operadores + e *:

[a] O operador de * (multiplicação) só pode ser usado entre um texto e um número inteiro, nunca entre dois
textos.

[b] O operador de + (concatenação) só pode ser usado entre dois textos, nunca entre um texto e um número.

(você vai perceber isso quando começar a receber as mensagens de erro caso tente desrespeitar essas regras)

3.3. Função print() com mais de um Parâmetro

Nós já sabemos que print() é uma função (mais adiante mostraremos o que isso significa). Nós também sabemos
que print() serve justamente para a saída de dados (ou seja, para mostrar na tela, para o usuário, aquilo que
estiver dentro dos seus parênteses).

É justamente sobre esses dados que eu quero falar agora: tudo aquilo que estiver dentro dos parênteses de uma
função é chamado de argumento (ou parâmetro) da função. Alguns gostam de dizer entrada (ou input) da função.
Por exemplo:

print("Não existe almoço grátis")

A frase "Não existe almoço grátis" é o argumento, ou parâmetro, ou entrada, ou input da função print() mostrada
acima. Já vimos que textos, números e expressões (cálculos) podem ser argumentos da função print(). Textos
devem vir entre aspas e os demais tipos não podem vir entre aspas.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 18

A função print() pode ser escrita recebendo mais de um argumento ao mesmo tempo, basta apresentá-los dentro
da função separados por vírgulas. Veja o exemplo:

print("Número", 30, 40 + 80, "Hoje" * 3)

Neste código, a função print() foi usada para mostrar 4 diferentes dados na mesma linha para o usuário separados
por um espaço. O resultado deste código será:

Número 30 120 HojeHojeHoje

Note dois detalhes importantes quando usamos a função print() informando a ela mais de um parâmetro:

[A] A saída da função print() (ou seja, seu resultado) apresentará os argumentos separados por espaços
automaticamente (você não precisará colocar o espaço dentro das aspas para separá-los, como faz na
concatenação com o +).

[B] A saída de cada função print() acontece numa linha só. Portanto, todos os parâmetros informados a uma
única função print() são apresentados numa única linha [diferentemente de quando você usa mais de uma
função print() – em que cada função apresentará sua saída em uma linha diferente].

A seguir, você verá o exemplo de usar quatro funções print() diferentes com um único argumento cada.

print("Número")

print(30)

print(40 + 80)

print("Hoje" * 3)

Isso vai dar o seguinte resultado:

Número

30

120

HojeHojeHoje

Percebeu? Cada função print() fez sua saída numa linha diferente.

Concatenar x Dois Parâmetros

Há algumas formas diferentes de obter um mesmo resultado no Python, especialmente com relação à função
print(). Veja esse caso:

Quando você manda mostrar na tela algum dado, usando o código:

print("Casa", "Amarela") #Aqui, pedi para exibir dois parâmetros

print("Casa " + "Amarela") #Aqui, concatenei dois textos

O resultado, na tela é:

Casa Amarela

Casa Amarela

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 19

Perceba que os dois resultados, visualmente, são iguais! Para o usuário que vai ler isso, não faz diferença se essa
mensagem foi feita com o uso de dois parâmetros, como na primeira linha ou com uma concatenação, como na
segunda linha.

Mas há uma diferença muito importante. Ela é uma diferença conceitual...

No caso do print("Casa", "Amarela"), você está solicitando exibir dois valores diferentes. São dois dados. Duas
Informações! São duas strings4 diferentes, mantidas separadas, e apenas apresentadas uma do lado da outra,
porque a função print() sempre separa as saídas com espaços.

No caso de print("Casa " + "Amarela"), você está pedindo para juntar (unir) as duas strings em uma só e, depois,
mostrar essa única string resultante. O "espaço" entre as palavras "Casa" e "Amarela" foi colocado dentro de
"Casa ". Neste caso, estamos exibindo apenas um dado!

Claro que o resultado, no final, para o usuário, foi o mesmo: então, não faz diferença usar um dos métodos ou o
outro. Mas, conceitualmente, para dentro do programa, são dois cenários diferentes! Só quero que você entenda
para não se perder mais adiante.

3.4. Vamos Exercitar?

O que será mostrado na tela nos comandos a seguir?

>>> print("Naruto " + "é melhor que " + "Dragon Ball")

>>> print(7* 3)

>>> print("7" * 3)

>>> print("Casa" * 4)

>>> print("Casa" + "4")

>>> print("Casa" * "4")

>>> print("Casa" + 4)

>>> print("Casa", 4)

Bônus: Aqui, estamos exibindo UM dado ou DOIS?

>>> print("Casa"+ "Casa")

>>> print(4, 4)

>>> print(8 * 4)

>>> print("Bom ", "dia!")

>>> print(3 * "Hoje ")

4
A palavra "string" significa "corda" ou "cadeia" (sequência). Quando usamos esta palavra, estamos nos referindo aos textos (que, no Python, são escritos
entre aspas), pois textos são cadeias de caracteres, ou seja, sequências de letras. Portanto, em resumo, string significa texto.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 20

4. Tipos de Dados no Python
4.1. Por que "Tipos" de Dados?
Tudo que você manipula no Python (textos e números) é considerado dado5.

[A] A letra "a" é um dado.

[B] O número 30 é um dado.

[C] A frase "vai faltar areia" é um dado.

[D] A Indicação de que algo é True (verdadeiro) ou False (falso) é um dado também.

O Python, assim como toda linguagem de programação, aceita apenas certos tipos de dados que precisamos
conhecer:

Integer (Inteiro)

Quando usamos números "não quebrados", ou seja, números inteiros, o Python os entende como tipo integer (ou
int, se você for mais íntimo).

Por padrão, todos os números que você utiliza no Python são do tipo integer (exceto, claro, aqueles números que
possuem casas decimais). Veja um exemplo de manipulação de números do tipo integer:

Ao lado, alguns comandos print() com números do tipo integer. Foram realizadas, inclusive, algumas
operações matemáticas com eles.

É bom lembrar de alguns detalhes:

[A] Somar dois números integer resultará num número integer;

[B] Subtrair ou Multiplicar números integer também resultará num integer;

[C] Elevar um integer a uma potência integer também gerará um integer como resposta.

[D] Apenas o resultado de uma divisão normal nunca é integer!

Para entender essa letra [D], precisamos conhecer um outro tipo de dado:

Float (Flutuante – Número não-inteiro)

Um número do tipo float é um número que está preparado para armazenar valores não-inteiros, ou seja, um
número que tem casa decimal (um número "quebrado"). Python, portanto, diferencia números inteiros (int) de
não-inteiros (float).

5
Um “dado” é qualquer representação de uma informação: um texto, um número, uma imagem, um som. Qualquer coisa que possa ser armazenada em uma
memória de computador é, naturalmente, um dado.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 21

Quando você divide dois números no Python, mesmo que esses dois números sejam inteiros, o resultado sempre
será um número float. Veja o exemplo abaixo:

Ao lado, algumas operações com números float. Note que o Python sempre coloca
casas decimais (separadas da parte inteira por um ponto).

Mesmo que você divida dois números integer, o resultado é necessariamente um float,
como aconteceu no primeiro comando mostrado, o print(32/17)

Note, também, que qualquer operação (soma, subtração, multiplicação) que envolva números float sempre
apresentará a saída (o resultado) como número float.

Então, para reconhecer: números float mostram casas decimais separadas da parte inteira por um ponto. Ou
seja, 2.0 é um float. Números integer não mostram o ponto. O 2 é um integer. Fácil, né?

String ("corda" de caracteres – ou seja, Texto)

O tipo string é o mais usado. Dados do tipo string são textos. Qualquer dado que você escreva entre aspas duplas
ou aspas simples é, automaticamente, classificado como uma string. Portanto, a palavra string significa texto!

Na janela ao lado, solicitamos a saída de alguns dados do tipo String.

Usamos, inclusive, os operadores + e * para fazer concatenação e

repetição de strings.

Chegamos no exato ponto deste curso em que dá para explicar melhor o uso dos operadores matemáticos com
vários tipos de dados: presta atenção agora...

Operadores Aritméticos e Seus "Segredos"

Operador + (Sinal de "mais")

Este operador é usado para somar ou concatenar.

[A] Se ele for usado entre dois números int, resultará na soma em formato int.

[B] Se ele for usado entre dois números em que pelo menos um deles é float, o resultado será a soma dos dois
em formato float.

[C] Se ele for usado entre dois dados do tipo string, o resultado é a concatenação em um novo string.

[D] Se tentar usá-lo entre uma string e um número qualquer, dará erro.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 22

 Alguns exemplos de operações feitas com o operador +.

Note o resultado de cada uma delas e compare com as

informações apresentadas acima.

Perceba, também, onde o erro ocorreu: justamente quando

tentamos usar o + entre uma string e um número.

Operador * (Asterisco)

Este operador pode ser usado para multiplicar e para repetir.

[A] Se ele for usado entre dois números int, resultará no produto (multiplicação) dos dois em formato int.

[B] Se ele for usado entre dois números em que pelo menos um deles é float, o resultado será o produto
(multiplicação) dos dois em formato float.

[C] Se tentar usá-lo entre uma string e um número integer, será gerada uma string contendo a repetição da
string original tantas vezes quanto for o valor do número.

[D] Se ele for usado entre uma string e um número float, ocorrerá um erro.

[E] Se ele for usado entre dois dados do tipo string, ocorrerá um erro.

Note que só há repetição do texto se o * for usado entre uma string e um integer.

Podemos ver exemplos do uso do * na imagem a seguir:

Exemplos de utilização do operador *.

Note os resultados de todas as multiplicações

com floats e integers.

E, claro, o erro no final do exemplo, ao tentar

operar uma string com um número do tipo float.

Operadores – (sinal de "menos") e /

(barra)

Esses dois operadores só podem ser usados entre dois números (int ou float, não importa). Não é possível usá-
los com strings (ou seja, dá erro).

Quanto ao operador – (subtração), temos que:

[A] Se ele for usado entre dois números integer, o número resultante será integer.

[B] Se ele for usado com pelo menos um float, o número resultante será float.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 23

Quanto ao operador / (divisão), temos a seguinte condição:

[A] Qualquer utilização deste operador gerará uma divisão entre dois números e o resultado sempre será um
float.

Exemplo do uso dos operadores – (subtração) e

/ (divisão). Perceba os resultados.

Esses dois operadores não podem ser usados

com textos, por isso ocorreu o erro na última
print que manda print("Casa" – 3).

Nem o operador / (divisão) nem o operador – (subtração) podem ser usados com strings (textos). Se você fizer
isso, o Python mostrará um erro, como foi visto na imagem acima.

4.2. Vamos Exercitar?

Indique quais os tipos dos dados a seguir:

"Não existe almoço grátis" 'Oba' + ' Legal'

18 18 + 9.0

18.0 3 * "Casa "

"18" "Erro " + "fatal"

'18+12' "Erro" + 40

18+12 3.0 * "Casa "

18/3 3.5 * 10

18*3 "Força " + "e Fé"

"Oba " * 3 45 * 30

"Oba " + "Legal" 34/2

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 24

5. Cálculos e Mais Cálculos
5.1. Revendo os Operadores Aritméticos
Na lição passada, fomos apresentados a alguns dos principais operadores aritméticos usados na linguagem
Python. Vamos revê-los rapidamente agora:

O operador + é usado para somar dois números. Portanto

print(80+50)

vai apresentar na tela o valor 130 (integer).

O operador – é usado para subtrair o segundo número de um primeiro número, portanto o trecho

print(90-30)

vai resultar no aparecimento do número 60 (integer).

Se você utilizar o operador * com dois números, você os multiplica. Logo, o código

print(30*4)

vai mostrar na tela o número 120 (integer).

Por fim, se você utiliza o operador /, você divide o primeiro número pelo segundo. Portanto,

print(20/5)

vai apresentar, na tela, o número 4.0 (float). (toda operação de divisão dá como resultado um número float).

Se você utilizar o operador ** (asterisco duplo), você elevará o primeiro número à potência do segundo número.
Isso significa que o código

print(3**2)

vai apresentar o número 9 (integer) como resultado na tela. (afinal, 32 é 9).

Todos esses já havíamos visto. Vamos a dois outros operadores relacionados à divisão entre dois números:

O operador // (barra dupla) é usado para obter o quociente de uma divisão inteira.

O operador % (sinal de porcentagem) é usado para obter o resto de uma divisão inteira.

O que são essas duas? Ahhh... você lembra da escola? Quando a gente aprendeu a calcular uma divisão com
resto? Era aquele tipo de cálculo que aqui chamamos de "divisão inteira" – uma divisão que usa apenas números
inteiros.

Sim, naquela época em que não tínhamos aprendido, ainda, a dividir números com casas decimais... a gente só
sabia trabalhar com números inteiros... relembre na próxima página.

Dá uma olhada na imagem a seguir, em que divido 14 por 3, obtendo 4 com resto 2:

14 3
quociente:
4  resultado do cálculo 14 // 3

resto: 2  resultado do cálculo 14 % 3

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 25

Então, é simples:

[A] Se você escreve 14 / 3, você obtém o resultado 4.666666666666667. (float, claro!)

[B] Se você escreve 14 // 3, você obtém o resultado 4 (o quociente) em formato integer.

[C] Se você escreve 14 % 3, você obtém o resultado 2 (o resto da divisão) em formato integer.

5.2. Prioridades na Frente!

Algumas vezes, somos obrigados a construir no Python expressões matemáticas com mais de um operador, como,
por exemplo: print(23 + 38 * 2 ** 5 // 8 % 4).

A pergunta que fica no ar é: como o Python entende (e resolve) uma expressão como essa? Será que é só ler
as operações da esquerda para a direita e calcular uma a uma em sequência?

O Python tem uma forma "organizada" de ler as expressões matemáticas e de resolvê-las: acompanhe a tabela
abaixo:

Primeiro... Python resolverá todas as operações com o ** (potência).

Depois... Python resolverá todas as operações de *, /, // e % - elas têm a mesma prioridade.

Por fim... Python resolverá todas as operações de + e – . Elas têm a mesma prioridade entre si.

Então, vejamos o código a seguir.

30 + 160 // 2 ** 5 / 5 – 12

A primeira coisa que o Python vai resolver é a potência, ou seja, o 2 ** 5. Isso dá 32 (integer), afinal, 25 = 32

30 + 160 // 32 / 5 – 12

Depois, todas as multiplicações, divisões e restos em ordem, da esquerda para a direita. Então, fará logo a
resolução do trecho 160 // 32. O resultado disso é 5 (integer) – divisão inteira.

30 + 5 / 5 – 12

Agora, resolve-se o 5 / 5, que resulta em 1.0. (float) – lembre-se: divisão com barra simples sempre retornará
um número float.

30 + 1.0 – 12

Agora é só soma e subtração. O resultado disto é 19.0. (float), porque o 1.0 era float.

Alterando as Prioridades

Normalmente, o Python fará as operações matemática na ordem das prioridades que eu mostrei acima. Mas você
pode fazer o Python realizar as operações em outra ordem: é só envolver com ( ) (parênteses) a parte da
expressão que você deseja que o Python resolva primeiro. Vamos ver?

40 – 8 * 3

O Pyhton vai resolver essa expressão assim:

[A] Primeiro, resolve a multiplicação 8 * 3, que dá 24;

[B] Depois, resolve a subtração 40 – 24, que dá 16.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 26

O resultado, portanto, é 16!

Se colocarmos os parênteses envolvendo a operação 40 – 8, o Python será obrigado a resolvê-la primeiro, antes
mesmo da multiplicação, ou seja:

(40 – 8) * 3

A resolução desta expressão será:

[A] 40 – 8 é resolvido primeiro, e dá 32.

[B] A multiplicação 32 * 3 é resolvida depois, resultando em 96.

O resultado, portanto, é 96.

Outro exemplo, apenas para fixar, é este:

30 + (21 – 13) / 4

O Python fará assim:

30 + (21 – 13) / 4 # Primeiro, resolve-se os parênteses (dá 8).

30 + 8 / 4 # Depois, resolve-se a divisão (dá 2).

30 + 2 # Agora, é só resolver a soma que falta.

32

Você poderá precisar, se seu cálculo for muito complexo, de vários níveis de parênteses. Um dentro do outro,
como veremos no exemplo a seguir:

3 * (10 // (2 + 3) + 8 * (4 – 3) + 2 ** (8 // (3 + 1) + 1))

Como o Python vai resolver isso?

Ei, João, posso tentar fazer

sozinho para ver se eu
entendi como funciona?

Claro que pode! Cubra as próximas linhas aqui abaixo com um papel e tente resolver você mesmo... depois,
descubra-as e veja a explicação passo-a-passo.

[A] Primeiro, resolvem-se todos os parênteses mais internos:

3 * (10 // (2 + 3) + 8 * (4 – 3) + 2 ** (8 // (3 + 1) + 1))

3 * (10 // 5 + 8 * 1 + 2 ** (8 // 4 + 1))

[B] Agora, os cálculos que têm prioridades dentro de cada parêntese restante:

3 * (10 // 5 + 8 * 1 + 2 ** (8 // 4 + 1))

3 * ( 2 + 8 + 2 ** ( 2 + 1))

[C] Agora, aqueles parênteses internos e aquela soma entre os dois itens iniciais:

3 * (2 + 8 + 2 ** (2 + 1))

3 * ( 10 + 2 ** 3 )

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 27

[D] Hora de resolver a potência, né? Depois somá-la ao 10 inicial para resolver os parênteses principais:

3 * (10 + 2 ** 3)

3 * (10 + 8)

3 * (18)

54

Lembre-se de que é o Python que vai fazer esses cálculos. Não Você! É importante, porém, que você saiba
exatamente como ele faz esses cálculos, porque você saberá escrevê-los de maneira a obter o resultado que
deseja.

Afinal de contas, escrever uma equação de maneira diferente trará resultados diferentes!

5.3. Vamos Exercitar?

Qual o resultado dos seguintes cálculos? [escreva-os aqui]

[A] 30 + 20 [I] 11 % 3

[B] 50 – 12 [J] (4 + 17) % 3

[C] 80 * 2 [K] 9 + 25 // 3

[D] 30 / 2 [L] 4 ** 3

[E] 100 – 25 * 2 [M] 80 + (33 // 4) ** 2

[F] 23 + 8 * 2 / 4 [N] 40 – (3 * 3) ** 2 // 4

[G] (90 – 10) * 2 / 5 [O] 80 / 2 ** (5 % 2)

[H] 7 // 2

O que vai ser apresentado na tela quando o programa abaixo for executado?
print("Calculadora " * 3)

print('Primeiros', 3 * 'testes ')

print(80 + 40 // 3 % 3)

print((100 - 60) / 20 + 3 ** 2)

print("Salva de", 7 * 3, "tiros")

print((3 * ((3 + 4 % 3) * 2 + 3) - 12) * 'bum ')

Escreva a saída (o resultado que aparecerá na tela do programa) aqui embaixo:

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 28

6. Variáveis
6.1. O que são Variáveis?
Variáveis são partes importantes de qualquer linguagem de programação. Uma variável é um pequeno "espaço
na memória do computador" utilizado para armazenar (guardar) dados.

Variáveis são utilizadas para que possamos usar os dados guardados nelas várias vezes.

Variáveis são como "caixas" onde podemos guardar dados para usá-los depois (como as caixas dos enfeites de
Natal que todos os fins de ano nós abrimos para pegá-los).

No exemplo ao lado, o número 30 é um dado, ou seja, um valor. E idade é uma variável:

é um "local" onde podemos guardar esse valor para usar depois.

Agora, o dado 30 foi colocado dentro da variável idade. Sempre que "apontarmos" para
a variável idade, o número 30 será devolvido como resposta.

6.2. Criando uma Variável

Para declarar (criar) uma variável, você só precisa dar a ela algum valor.

Declarar uma Variável: é dizer ao programa que ela existe – ou seja, é criá-la. No Python, quando você atribui
um valor a uma variável pela primeira vez, ela é automaticamente criada.

Atribuir um Valor a uma Variável: é colocar algum valor dentro dela.

Lembre-se: para usar uma variável no seu programa (mencioná-la em cálculos, por exemplo), precisamos criá-
la primeiro.

Mas como se
faz isso no
Python, João?

É bem fácil, amigo leitor! Basta usar a expressão variável = valor.

idade = 30

Esse é o código usado no Python para fazer o que a figura anterior mostra: vai criar um espaço na memória
chamado idade e vai colocar lá dentro o valor 30.

Para que você possa entender melhor, imagine que o sinal de = se chama "recebe". Então, o código

distancia = 300

pode ser lido como "a variável distancia recebe o valor 300".

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 29

 João, posso dar
qualquer nome
para uma variável?

Não, meu amigo! Há algumas regras que devem ser respeitadas.

[A] Nomes de variáveis devem conter apenas letras, números e _ (underline).

[B] Nomes de variáveis não podem começar com números.

idade = 30

idade2 = 28

idade_cachorro = 8

_idade = 10

3idade = 18 # Isso dá erro (não funciona)

O Python é uma linguagem case-sensitive (significa que faz diferença entre maiúsculas e minúsculas). Portanto,
a variável Idade é diferente da variável idade, que é diferente da variável IDADE.

Cuidado: às vezes, o programador nomeia a variável com letra maiúscula e depois tenta usá-la com letra
minúscula – o Python não vai aceitar isso! Preste atenção a como escreve os nomes das variáveis! Afinal, você
não pode mencionar uma variável que não foi declarada!

6.3. Usando Variáveis

Depois de criar uma variável, é possível usá-la em qualquer expressão apenas se referindo ao nome dela. Usar
uma variável, portanto, é mencioná-la. Veja a seguir:

a = 30 # Aqui, a variável a está sendo declarada

b = 40 # Aqui, a variável b está sendo declarada

print(a + b) # Aqui, as variáveis a e b estão sendo mencionadas (usadas)

Perceba que eu criei a variável a com o valor 30, depois criei a variável b com o valor 40. Por fim, usei a função
print() mencionando a soma entre o a e b. O resultado do código acima será

70

Lembre-se de que não é possível usar (mencionar) uma variável que nunca foi declarada antes. Isso vai gerar
um erro. Veja esse código:

a = 10

print(a + b)

O Python vai, com certeza, reclamar que não consegue entender o que é b. O código acima está mencionando
(chamando) uma variável b que nunca foi declarada antes, ou seja, para este nosso exemplo, o Python sabe que
b não existe!

Lembra que para criar (declarar) uma variável, é necessário apenas atribuir um valor para ela. Ao atribuir o
primeiro valor, a variável é automaticamente criada.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 30

Depois de atribuir o primeiro valor a uma variável, declarando-a, é possível modificar o conteúdo da variável
quantas vezes você quiser. Basta, para isso, atribuir novamente outro valor a ela (por isso que o nome é variável:
porque seu valor pode variar)!

idade = 30

idade = 43

idade = 28

print(idade)

O resultado do código acima é

28

Perceba que, primeiramente, havíamos colocado o valor 30 na variável idade. Depois, substituímos ele pelo valor
43 (e o 30 foi esquecido). Por fim, atribuímos o valor 28 à variável, fazendo com que ela esqueça o valor 43.
Atualmente, portanto, a variável idade possui o valor 28.

Ô João, então quer dizer que sempre que a gente

atribui um novo valor a uma variável que já tinha
algum valor, o valor anterior é substituído pelo novo?

Sim, meu caro! Quando atribuímos um novo valor a uma variável, esse novo valor substitui completamente o
valor que havia anteriormente.

Mas você pode substituir o valor antigo por um valor que é atualização dele (é o que eu chamo de "levar em
consideração" o valor anterior). Veja um exemplo abaixo:

idade = 30

idade = idade + 1

print(idade)

Esse nosso programa funcionará assim:

[A] Primeiro, a variável idade recebe o valor 30;

[B] Depois, somamos o valor contido em idade (que é 30) com o número 1 e a variável idade recebe este novo
valor. Ou seja, idade agora tem 31 (substituiu o 30).

[C] Mandamos exibir o valor atual da variável idade com a função print().

O resultado apresentado será

31

Resumidamente, a instrução idade = idade + 1 significa "a variável idade vai receber um novo valor: que é o
valor atual da variável idade somado ao número 1".

Podemos fazer isso com qualquer outra operação aritmética. Vejamos alguns exemplos:

a = 10

b = 20

c = 30

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 31

 d = 40

a = a – 3 # a receberá o valor atual de a subtraído de 3.

b = b * 2 # b receberá o valor atual de b multiplicado por 2.

c = c / 4 # c receberá o valor atual de c dividido por 4.

d = d % 6 # d receberá o resto da divisão do valor atual de d por 6.

print(a, b, c, d)

Atenção: o comando print(a, b, c, d) vai mostrar na tela, lado a lado, separados por espaços, os valores das
variáveis a, b, c e d. O resultado deste programa será a apresentação, na tela, dos valores:

7 40 7.5 4

Podemos fazer esta operação de adicionar, subtrair, multiplicar, dividir ou calcular resto com o valor que já havia
na variável usando uma outra forma de escrever: +=, -=, *=, /=, //=, %= e **=.

Escrever a expressão num = num + 1 é o mesmo que escrever a expressão num += 1. Do mesmo modo que
escrever a expressão desconto = desconto – 10 é o mesmo que escrever desconto -= 10. Então, o código:

a = 10

b = 20

c = 30

d = 40

a += 5 # É o mesmo que a = a + 5

b *= 3 # É o mesmo que b = b * 3

c /= 10 # É o mesmo que c = c / 10

d **= 2 # É o mesmo que d = d ** 2

print(a, b, c, d)

resultará em

15 60 3.0 1600

E só para lembrar, meu amigo leitor, minha amiga leitora, esses sinais (+=, -=, *=, /=, //=, %= e **=) devem ser
escritos necessariamente juntos (não se admitem espaços entre eles, ok?). Esses sinais de atribuição de
variáveis são chamados de “augmented assignment” (ou, traduzindo, são sinais de “atribuição de incremento” ou
sinais de “atribuição de aumento”).

Mais Detalhes sobre variáveis

Vamos analisar mais algumas linhas de atribuição de variáveis? Dá uma olhada aqui:

frase = "palavra"

palavra = "hoje"

hoje = frase

amanha = palavra + hoje

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 32

Na primeira linha, a variável frase recebe a string "palavra". Na segunda linha, a variável palavra recebe a string
"hoje". Depois, a variável hoje recebe o mesmo valor que está na variável frase (ou seja, a string "palavra"). Por
fim, a variável amanha recebe a concatenação dos valores existentes nas variáveis palavra e hoje, ou seja, a
string "hoje" concatenada com a string "palavra".

Ao término deste programa, se pedirmos:

print(frase, palavra, hoje, amanha)

Vamos ter o resultado:

'palavra' 'hoje' 'palavra' 'hojepalavra'

Não confunda! Olha os dois exemplos abaixo:

var1 = "hoje"

var2 = hoje

A variável var1 recebe a string "hoje". A variável var2 recebe o conteúdo que está na variável hoje. Perceba, na
linha da var2, a ausência de aspas, indicando que aquele hoje é o nome de uma variável e não uma string.

E é claro que vale a pena lembrar que esta última linha só vai funcionar se a variável hoje já tiver sido declarada
antes.

Atribuindo Valores a Múltiplas Variáveis

Uma das coisas que você poderá usar várias vezes no Python é que você pode atribuir valor a mais de uma
variável numa única linha. Basta separar as variáveis por vírgulas e os valores também! Ou seja, o código:

nome, idade, altura = "João", 46, 1.90

é a mesma coisa que digitar

nome = "João"

idade = 46

altura = 1.90

Mais um exemplo para ilustrar essa técnica:

var1, var2 = 20, 30

var1, var2 = var2+var1, var2*var1

print(var1, var2)

Neste exemplo, inicialmente, a variável var1 recebe 20 e a variável var2 recebe 30. Na segunda linha, a variável
var1 recebe a soma entre var2 e var1, ou seja, 30 + 20, ou seja, 50 e a variável var2 recebe a multiplicação
entre var2 e var1, ou seja, 30 * 20, ou seja, 600.

O comando print(var1, var2) vai mostrar, portanto:

50 600

Vale aqui lembrar que se você coloca 3 variáveis antes do =, você deverá citar 3 valores depois do =. Ou seja, se
você menciona X variáveis, deverá atribuir X valores a elas. Qualquer diferença entre as quantidades de variáveis
e de valores, dará erro.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 33

 Na primeira linha, 3 valores (10, 4 e “Casa”)
foram atribuídos a 3 variáveis (a, b, c). Deu
certo!

O comando seguinte não deu certo porque

tentei atribuir dois valores (30, 40) a três
variáveis (d, e, f) e, por isso deu erro.

O terceiro comando deu erro também,

porque tentei atribuir 3 valores (34, 40 e
“Teste”) a apenas duas variáveis (d, e).

O último comando deu erro porque não

podemos usar aumentadores (+=) com
mais de uma variável.

Só para explicar o último exemplo da imagem acima: não podemos usar os sinais de atribuição de incremento
(os sinais +=, -=, *= e /=) com mais de uma variável por vez.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 34

6.4. Chegou a Hora de Exercitar

Quais os resultados dos códigos abaixo?

velho, novo = 17, 30

problema = novo – velho

problema = problema * 2

velho -= 7

print(novo, velho, problema)

eco = "Mises"

times = 3

times = times * 2

more = times + 4

print(eco * more)

base, expoente = 4, 10

expoente = base // 2

print(base ** expoente)

altura, base = 10, 20

altura, base = base * 3, altura + 5

area = base * altura

print(area, base*3, altura+10)

raio, cons = 15, 3

cons *= 2

raio += 2

resposta = cons + raio % 3

print(resposta, cons + raio, raio ** 2)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 35

7. Comentários e Textos Longos
7.1. Comentários e Erros – Programa de Exemplo
Vamos fazer um programa simples que armazene dois números em duas variáveis diferentes e apresente vários
cálculos aritméticos usando ambos.

a, b = 10, 2

print("=" * 30)

print("Calculadora Simples")

print("=" * 30)

print("A soma entre eles é: ", a + b)

print("A subtração entre eles é:", a – b)

print("A multiplicação entre eles é:", a * b)

print("A divisão entre eles é:", a / b)

print("A divisão inteira entre eles é:", a // b)

print("O resto da divisão entre eles é:", a % b)

print(a, "elevado à", b + "a", "potência é", a ** b)

O resultado deste programa simples é:

==============================

Calculadora Simples

==============================

A soma entre eles é: 12

A subtração entre eles é: 8

A multiplicação entre eles é: 20

A divisão entre eles é: 5.0

A divisão inteira entre eles é: 5

O resto da divisão entre eles é: 0

10 elevado à 2a potência é 100

Mudando os valores das variáveis a e b, é claro, você mudará os resultados do programa.

Comentários Curtos

Vamos agora aprender a "comentar" nosso código. Escrevemos comentários para entendê-lo melhor em caso de
termos de lê-lo posteriormente – sempre é bom criar um "manual de instruções" no código.

Para fazer comentários curtos (uma linha apenas), use o caractere # (hashtag, ou "jogo da velha"). Tudo aquilo
que você escrever após este símbolo é automaticamente entendido como comentário.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 36

Atenção: comentários são trechos de texto que o Python não vai obedecer. Esses textos existem no código em
si, mas nunca serão executados. São apenas para "orientar" o programador. São "lembretes" ou "avisos".

Veja um programa simples com comentários:

# Aqui declaramos as variáveis que vamos usar

a = 20

b = 30

# Aqui um pequeno "cabeçalho" para o programa

print("=" * 30) # Repita o sinal de "=" 30 vezes

print("Calculadora")

# Aqui começam os cálculos

a = b + c # Aqui vai dar um erro!

b = a + 30

Como você pôde perceber, comentários podem ser escritos numa linha única (sozinhos) ou em uma linha que
possui comandos (tudo o que aparecer depois do # será entendido como comentário).

Agora, olhe o código novamente e perceba que na penúltima linha há um comentário que diz "Aqui vai dar um
erro!" – você pode imaginar por quê?

Deixa eu ver, João! Será que é porque a

variável c está sendo requisitada, mas
ela nunca foi declarada antes?

Exatamente!!! Muito bem! Não é possível pedir que a variável a receba a soma de b com c, se nós simplesmente
nunca ouvimos falar de c. A variável c simplesmente não existe porque ela nunca foi declarada! (é um erro
comum entre os programadores – até os mais experientes).

Comentários Longos (Várias Linhas)

Para fazer comentários longos, textos de documentação grandes, você pode escrever todo o comentário desejado
entre " " " (três aspas duplas) ou ' ' ' (três aspas simples). Coloque-os antes e depois do texto a ser digitado e
todo ele será desconsiderado – totalmente ignorado (será considerado comentário).

Veja um exemplo de um programa simples:

"""

Este programa foi criado para exemplificar o uso dos comentários de várias linhas. Basta
colocar o trecho que será usado como comentário entre grupos de 3 aspas. Tanto faz se são
aspas duplas ou aspas simples.

"""

a = 90

b = 20

c = 30

print(a + b - d) # Vai dar erro porque não declaramos a variável d

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 37

As aspas triplas também podem ser usadas para colocar uma string (texto) com mais de uma linha, por exemplo,
na função print(). Veja um exemplo:

print("""Pequeno Poema

Subi num pé de manga pra tirar abacaxi.

Como não era tempo de morango, Roubaram minha bicicleta.""")

Uma grande vantagem de usar as aspas triplas é que se você colocar aspas normais no meio do texto, elas serão
entendidas como parte do texto, sendo apresentadas assim ao usuário. Veja o exemplo:

Print('''Este texto tem "aspas" em seu interior.''')

Será apresentado ao usuário o seguinte:

Este texto tem "aspas" em seu interior.

Notou que as aspas na palavra "aspas" foram mostradas ao usuário? Isso aconteceu porque o Python entendeu
que o delimitador de texto era as aspas simples (apóstrofos) triplas ('''), entendendo as aspas normais como
caracteres que são parte integrante do texto.

Ao usar a função print() com as aspas triplas, você pode mandar imprimir na tela exatamente a mesma
organização de texto que escreve dentro das aspas triplas. Linha por linha.

7.2. Vamos Exercitar a Lição 7

Quais os resultados dos programas abaixo? Eles dão erro? Eles funcionam?
# Programa para repetir um valor textual várias vezes

Letra = '''A "Casa" Amarela.'''

numero = 3

print(letra * numero)

# Programa de Exemplo para multiplicar variáveis

1num, 2num = 10, 20

print(1num * 2num)

# Programa de Exemplo para multiplicar variáveis

Agora com nomes corretos das variáveis

x, y = 10, 20

print(x * y)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 38

8. Tipo de Dados Booleano (Falso / Verdadeiro)
8.1. O que é Booleano?
Já conhecemos alguns tipos de dados que o Python entende, como integer, float e string. Chegou a hora de
conhecer um outro tipo de dado: o tipo boolean (ou "booleano"). Dados em formato booleano só podem receber
dois valores contrários: False (falso) ou True (verdadeiro).

Note bem, amigo leitor, o valor False é diferente de "False". False é um conceito, uma ideia, um estado de falsidade.
O valor "False" é um texto, uma string (se está entre aspas, é uma string).

Da mesma forma que True é uma ideia que indica um estado de verdadeiro e "True" é uma string. Podemos
informar que uma variável é diretamente True ou False do mesmo jeito como fazemos em qualquer outro tipo de
valor:

teste = False

aprovado = True

Atenção: ao se referir aos valores booleanos, você deve escrevê-los True e False (com a primeira letra
maiúscula e sem aspas). Escrevê-los de outra forma faz o Python entender como outro tipo de dados, mas não
booleano.

Outra forma de obter os valores False e True é usar proposições (normalmente expressões que usam os
operadores de comparação).

Proposição: é uma expressão que só pode assumir dois valores: ou ela é verdadeira, ou é falsa.

Operadores de Comparação (ou Operadores Relacionais): são sinais que realizam a comparação entre valores
e/ou expressões.

Vamos a um exemplo? A expressão 20 > 30 quer dizer vinte é maior que trinta. Nós sabemos que isso é False.
Do mesmo modo que 20 < 30 significa vinte é menor que trinta. Isso é True.

Então, olha que lindo! Operadores de comparação são justamente esses sinais (> e <, nos exemplos acima). Com
esses operadores, nós comparamos o que está antes do operador com o que está depois.

Vamos conhecer todos eles?

20 > 30 (vinte é maior que trinta) 20 < 30 (vinte é menor que 30)

20 >= 30 (vinte é maior ou igual a 30) 20 <=30 (vinte é menor ou igual a 30)

20 == 30 (vinte é igual a 30) 20 != 30 (vinte é diferente de 30)

Atenção: o sinal de comparação "igual" é necessariamente um == (igual duplo) porque o uso do sinal de = (igual
único) é para atribuir valores a variáveis, como já estamos fazendo há algum tempo.

Então, podemos testar algumas proposições?

a, b, c = 20, 10, 30

print(a > b)

print(c <= b)

print(a + 2 * c) # Aqui não é uma proposição porque não tem comparação

print(a * 2 > c + b)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 39

O resultado deste programa é que aparecerá na tela o seguinte:

True

False

80

False

Portanto, o valor False indica que a proposição não é verdadeira (ou seja, ela é falsa). O valor True indica que a
proposição é verdade. Os valores "True" e "False" são apenas textos (strings).

Podemos usar valores booleanos em uma série de momentos no Python, mas vamos usá-las especialmente em
estruturas de decisão (condicionais) e estruturas de repetição (loop).

8.2. Comparação com Textos

Estamos acostumados a entender as operações de comparações com números, pois é fácil entender, por exemplo,
a expressão 8 > 12 e imediatamente compreender que ela é False.

Mas podemos fazer comparações entre valores do tipo string também – e o Python é um tanto "esperto" em
relação a elas. Inicialmente, vamos comprar textos usando "igual" e "diferente":

"Casa" == "Escola"

"Casa" != "Escola"

O resultado dos dois comandos acima será:

False

True

Isso porque a String "Casa" é diferente da string "Escola" (deu pra notar, né?).

Mas uma coisa que poucos sabem (e parece não ter lógica) é que podemos usar comparadores como "maior que"
e "menor que" também com as strings.

Peraí, João, aí não dá para aceitar!

Como é que o Python vai decidir se
"Casa" é maior que "Escola"?

Calma, meu amigo! É pela posição no dicionário das strings, ou seja, pela ordem alfabética. Resumindo, os
comandos:

"Casa" < "Escola" # "Casa" vem antes de "Escola" no dicionário

"Mises" >= "Marx" # "Mises" vem depois ou igual a "Marx" no dicionário

"Liberdade" <= "estado"

Resultarão, respectivamente, em:

True

True

False

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 40

Vale a pena lembrar: sempre que existir um operador de comparação numa expressão, por maior que ela seja, o
seu resultado será True ou False (ou seja, será booleano).

Por exemplo, a expressão

teste = 43 * (6 + 4)

vai colocar o valor 430 dentro da variável teste.

Já a expressão

teste = 43 * (6 + 4) > 50 * 100

vai colocar o valor False na variável teste, porque 430 não é maior que 5000.

8.3. Vamos Exercitar?

Qual o valor da variável teste nos vários casos a seguir?

[A] teste = 80 + 40

[B] teste = 80 < 40

[C] teste = 2 * 40 > 4 * 10

[D] teste = 4 * 10 – 30

[E] teste = 4 * 10 – 30 < 20 * 2

[F] teste = 80 == 80

[G] teste = "Indivíduo" > "Estado"

[H] teste = "Imposto" >= "Liberdade"

[I] teste = 30 * 12

[J] teste = 100 * 2 > 10 ** 3

[K] teste = 20 + 5 != 5 ** 2

[L] teste = 80 % 9 == 2 ** 3

[M] teste = 50 + 10 <= 20 * 3

[N] teste = 40 + 30

[O] teste = 2 * 4 ** 2 + 10

[P] teste = 2 ** 5 > 3 * 10

[Q] teste = 80 + 15 < 10 ** 2 - 5

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 41

9. Algumas Funções Built-in (Já Existentes)
9.1. O Que são Funções?
Funções são pequenos trechos de código que podem ser reutilizados. Numa lição posterior, aprenderemos a criar
as nossas próprias funções.

Praticamente, todas as funções são escritas do mesmo jeito: nome_da_função(argumentos). Você precisa
conhecer o nome da função para usá-la – e você precisa saber quais argumentos ela aceita para ela funcionar
corretamente.

Pense numa função lavar() que serve para, digamos, lavar objetos. Aí, usar lavar(carro) poderia ser,
hipoteticamente, a forma de mandar lavar o carro e lavar(bicicleta) serviria para mandar lavar a bicicleta. (tá, ok,
isso é só um exemplo "bem besta" para explicar funções).

A função print() já conhecemos – ela é usada para imprimir (na tela) aquilo que estiver colocado como argumento
(dentro dos parênteses).

O Python já traz consigo diversas funções prontas (além da print()) – chamamos elas de "built-in" (algo como
"essas funções já vêm construídas dentro no Python"). Há funções para manipular números, textos e outros tipos
de dados. Vamos conhecer algumas delas agora...

9.2. Funções de Conversão de Dados

A função int() serve para converter um número float ou string para um número no formato integer.

Ou seja, o comando int(7.5) vai resultar em 7. O comando int("8") vai resultar em 8. Note que o primeiro valor era
um número float e o segundo exemplo era uma string.

A função float() converte um número integer ou uma string em um número no formato float.

Exemplos? Agora mesmo! Se você escrever float(8), isso resulta em 8.0. Se você escrever float("10"), isso vai
gerar, como resultado, o número 10.0.

Atenção: nem a função int( ), nem a função float( ) vão funcionar se o valor string não for "escrito só com números".
Por exemplo, vai aparecer erro se você tentar usar int("casa") ou float("escola") (não tem como converter esses
aqui para números, né?)

A função str( ) é usada para converter qualquer valor em uma string (texto). Pode ser usada com números integer
ou float.

Então, usar a função str(18) vai resultar em "18", e usar a função str(10.0) vai resultar em "10.0".

A função bool() é usada para converter qualquer valor (número ou string) para um valor booleano (True ou False).
A norma, porém, é um tanto "curiosa":

[a] Se tentar converter o número 0 ou uma string vazia, o resultado será False.
[b] Em qualquer outro caso, o resultado será True.
Portanto, nos casos a seguir:

bool("casa")

bool(34)

bool(0)

bool("")

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 42

teremos os resultados seguintes

True

True

False

False

9.3. Funções Numéricas Gerais

A função sum() é usada para somar dois ou mais números. Ou seja, se você usar sum([10,20]), o resultado será
30. O argumento da função sum() tem que ser escrito entre colchetes, o que, para o Python, significa uma lista,
o que chamamos de objeto iterável ou sequência de valores (vamos ver isso adiante).

O resultado de sum([1, 2, 3, 4, 5, 6]) será 21. Nem preciso dizer que o mesmo que escrever 1 + 2 + 3 + 4 + 5 + 6,
né?

Não esqueça: não dá para usar a função sum() diretamente com os números, como em sum(1,2,3,4,5) – isso dá
erro. A função sum() tem que ser escrita com uma lista em seu interior (ou seja, os valores entre colchetes),
como em: sum([1,2,3,4,5]).

A função max() pode ser usada com vários valores [sem colchetes] ou com uma lista, como a função sum(). A
função max() retorna o maior valor encontrado nos argumentos.

Então, a função max(2, 40, 5, 82, 13) retornará o valor 82.

Um aviso: a expressão "tal função retornará tal valor" significa que "tal função resultará em tal valor". Ou seja,
o verbo "retornar" é usado como sinônimo de "resultar". Nós vamos aprender que nem toda função retorna um
valor, mas quando esse verbo for usado, é porque a função irá trazer resultados.

A função min() é irmã “mais nova” da max(). Ela retorna o menor valor apresentado nos argumentos. Portanto, a
função min(2, 40, 5, 82, 13) retornará o valor 2.

A função round() serve para arredondar um número para uma determinada quantidade de casas decimais. Para
isso, escreva round(número, núm_casas). Um exemplo?

Claro! Aqui vai: O comando round(12.3945, 1) vai retornar 12.4, que é o número 12.3945 sendo mostrado com
apenas 1 casa decimal. Quando você não informa o número de casas, o Python corta todas (ou seja, converte o
número para um integer).

round(21.3298)

Isso vai retornar:

21

Mais uma função? Que tal a função len()? A função len() conta a quantidade de itens de uma lista ou de caracteres
em uma string. Ou seja, a função len("Mises") vai retornar 5, porque "Mises" tem 5 caracteres.

Escrever a função que retorna valor sozinha numa linha do editor de código não adianta: ou você aponta o
resultado da função para uma variável, ou manda imprimir na tela por meio da função print(), como mostramos
aqui:

num_maximo = max(1, 3, 9, 5, 2, 8) # Atribuindo a uma variável

print(int(20/6)) # Imprimindo direto na tela

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 43

A função abs() é usada para transformar um número em seu módulo (número absoluto), ou seja, sem o sinal. Ela
deve ser escrita assim: abs(número), onde número é o valor numérico para o qual se deseja obter o valor absoluto.

>>> abs(-9)

>>> abs(2)

A função pow() é usada para elevar um valor a uma potência. Ela deve ser usada assim: pow(base,expoente)
para elevar o número base ao expoente.

>>> pow(9,2)

81

>>> pow(2,9)

512

A função pow() tem o mesmo objetivo do operador **, percebeu? Ou seja, as expressões pow(3,2) e 3**2 retornam
exatamente o mesmo valor (que é 9).

9.4. Vamos Exercitar sobre a Lição 9

Quais os resultados das Funções abaixo?

int("5")

max(2, 5, 6, 1, 4, 3)

str(123)

min(20, 3 + 4, 15, 5 * 2)

bool("Escola")

float(int(3.5) + int(4.5))

sum([3, 4, 7*2, 5])

pow(3*2, 12//6)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 44

10. Recebendo Dados do Usuário
10.1. A Função de Entrada de Dados – input( )
Usamos a função print() para enviar mensagens ao usuário (ou seja, mostrar coisas na tela para que o usuário
leia).

Algumas vezes, porém, precisaremos pedir dados ao usuário (esperar que ele digite algo). Isso é trabalho para
a função input( ). A função input( ) é usada para a entrada dos dados (a print() é para a saída).

Atenção: chamamos de entrada de dados o ato de o usuário inserir dados no computador (quando o programa
pede ao usuário que ele digite algo).

Sempre que você precisar que o usuário informe algo, como o nome dele ou a idade, você deverá usar a função
input().

A função input() é usada sempre deste jeito: variável = input(mensagem). Ou seja, a função input() deve ser usada
numa atribuição de variável, para que o valor que o usuário digitar seja armazenado diretamente na variável
apontada. O argumento mensagem é o texto que aparecerá para o usuário antes de ele digitar o dado pedido.
Vamos a um exemplo:

# Programa para exibir Nome e Idade

nome = input("Digite o seu nome:") # Pede o nome do usuário

idade = input("Digite a sua idade:") # Pede a idade dele

# Exibir uma linha formada por 30 asteriscos

print("*" * 30)

# Exibir os Dados

print(nome, "tem", idade, "anos de idade.")

O resultado deste programa é:

Digite o seu nome: João Antonio

Digite a sua idade: 46

*****************************

João Antonio tem 46 anos de idade.

Depois de inserir cada valor pedido, o usuário deverá pressionar ENTER para confirmar. Portanto, considere que
depois de ter digitado João Antonio, o usuário pressionou ENTER. Considere também que depois de ter digitado
46, o usuário também pressionou ENTER.

Um alerta importante: todas as vezes que você usa a função input( ), o dado que ela captura é, necessariamente,
uma string (mesmo que você digite um número como a idade de alguém).

Isso significa que se você quiser usar um dado capturado pela função input( ) para fazer cálculos, é bom passar
ele numa função de conversão antes. Por exemplo:

idade = int(input("Digite a idade:"))

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 45

No exemplo acima, o resultado da função input (digitado pelo usuário) será usado como argumento (entrada) da
função int(). A função int() retornará esse valor convertido para integer. O que será armazenado na variável idade
é o número integer resultante desta conversão.

Esse código deixa isso mais claro:

>>> idade = input("Digite a idade:")

Digite a idade: 45 # O usuário digitou aqui!

>>> print(idade)

'45' # Note que aqui o 45 é um texto [está entre aspas simples]

>>> idade = int(idade) # Aqui convertemos a variável idade

>>> print(idade)

45 # Note que aqui o 45 é número pois não tem aspas

Então, não se esqueça:

[A] Para capturar informações digitadas pelo usuário, use a função input().

[B] A função input() deve ser apontada para uma variável, ou seja, seu resultado deve ser colocado na atribuição
de uma variável.

[C] A função input() sempre retorna um valor textual (string). Isso significa que tudo aquilo que for capturado
pela função input() é considerado texto.

[D] Se quiser usar um dado capturado pela input() em cálculos, é necessário converter para número (inteiro ou
float).

10.2. Vamos Exercitar esta Lição?

Escreva um programa que peça o nome e a idade do usuário e, em seguida, imprima na tela a
mensagem "<nome> tem <idade> anos de idade" (substitua <nome> e <idade> pelos dados
que o usuário inserir).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 46

Escreva um programa que receba dois números, a largura e a altura de um retângulo e
apresente na tela a mensagem "A área do retângulo é <Área> ." (Substitua <Área> por
largura * altura).

Qual o resultado, impresso na tela, dos programas abaixo?

num1 = input('Digite o primeiro número:') # Usuário digita 10

num2 = input('Digite o segundo número:') # Usuário digita 20

print(num1 + num2)

num1 = input('Digite o primeiro número:') # Usuário digita 40

num2 = int(input('Digite o segundo número:')) # Usuário digita 5

print(num1 * num2)

print("=" * 10)

print("Calculadora")

print("=" * 10)

num1 = int(input('Digite o primeiro número:')) # Usuário digita 30

num2 = int(input('Digite o segundo número:')) # Usuário digita 7

print(int(num1/num2))

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 47

11. Listas
11.1. O que são listas?
Lembra-se das variáveis, né? Variável é uma estrutura de dados (uma "peça" da linguagem de programação que
serve para armazenar dados). Veja os exemplos a seguir:

nome = "Ludwig von Mises"

idade = 103

A variável nome está guardando apenas uma string e a variável idade está guardando apenas um número
(porque UMA variável só consegue guardar UM dado).

Sim! Uma variável "comum" só tem espaço para guardar um dado! Só UM!

E é por isso que existem "outros tipos" de estruturas de dados que precisamos aprender! Estruturas que
armazenam mais do que apenas um dado! Uma lista é um desses tipos de objetos! Uma lista é como se fosse
uma "variável que pode ter muitas gavetas".

Uma lista é um dos objetos do tipo "set" (conjunto ou sequência). Há vários tipos de objetos assim, como tuplas e
dicionários. Vamos conhecer eles mais adiante.

Para criar uma lista, você atribui os valores que quiser inserir na lista dentro de um par de colchetes, ou seja,
esses símbolos aqui: [ ]. Os elementos dentro da lista são separados por vírgulas.

Vamos criar uma lista chamada economistas no exemplo a seguir:

economistas = ["Hayek", "Mises", "Sowell", "Rothbard"]

Se você pedir para mostrar a lista economistas, vai aparecer isso:

>>> print(economistas)

['Hayek', 'Mises', 'Sowell', 'Rothbard']

Você pode pensar numa lista como sendo uma "tabela" com uma linha de dados apenas. Olha o exemplo a seguir
para ilustrar a lista do exemplo acima:

economistas
Hayek Mises Sowell Rothbard

Adicionando mais um item à Lista

Para adicionar mais um valor à lista, usa-se o método .append( ).

Método: é uma função especial que é escrita como um "sobrenome" de um objeto. Um método é normalmente
específico para um tipo de objeto. Usamos métodos escrevendo o nome do objeto, um ponto e o nome do método.
Assim: objeto.método( ).

O método append(dado) é usado apenas em listas. No caso do exemplo acima, usaríamos

economistas.append('Marx') para adicionar a string 'Marx' no final da lista economistas. O resultado, ao pedir
para exibir a lista economistas será:

>>> print(economistas)

['Hayek', 'Mises', 'Sowell', 'Rothbard', 'Marx']

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 48

Apagando um Item da Lista

Para apagar o último item de uma lista (ou seja, tirar o Marx da nossa lista de economistas, já que ele não
entendia bulhufas de economia), basta usar o método .pop( ). Deste jeito:

>>> economistas.pop()

'Marx' # No Shell, o Python exibe o valor e o apaga da lista

>>> print(economistas)

['Hayek', 'Mises', 'Sowell', 'Rothbard']

Note que, ao usar o método .pop( ), o Python retorna (responde) com o valor que está sendo retirado da lista (Só
no Shell). Depois, ao mandar exibir a lista, dá para ver que o último item foi retirado (graças a Deus).

Ô João, e se eu quiser buscar

(para exibir) apenas um item
da lista, como posso fazer?

Você tem que usar a expressão lista[índice] para acessar diretamente um item da lista. Para explicar melhor,
vamos entender que cada posição na lista tem um endereço próprio, que começa com o número 0 (zero). Veja
o exemplo para a lista abaixo:

economistas
0 1 2 3
Hayek Mises Sowell Rothbard
Esta lista tem 4 posições (ou itens). A posição 0 contém a string 'Hayek', a posição 1 contém a string 'Mises' e
assim por diante. Quer mostrar na tela o conteúdo da posição 2 da lista? Olha abaixo:

>>> print(economistas[2])

Sowell

Se você quiser alterar o conteúdo de uma posição, é só apontar para ele como se fosse uma variável e atribuir
um novo valor:

>>> economistas[2] = 'Keynes' # Atribuímos o valor à posição 2

>>> print(economistas)

['Hayek', 'Mises', 'Keynes', 'Rothbard']

Apagando Qualquer Item da Lista (não apenas o último)

O método .pop( ) pode ser usado para apagar qualquer item da lista, não somente o último. Para isso, basta você
indicar, dentro dos parênteses, qual o índice do item que você deseja apagar da lista. Veja o exemplo do código:

>>> print(economistas)

['Hayek', 'Mises', 'Sowell', 'Rothbard']

>>> economistas.pop(1) # Retornará e apagará o item na posição 1

'Mises'

>>> print(economistas)

['Hayek', 'Sowell', 'Rothbard']

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 49

Outros Métodos Interessantes para Listas

Vamos saber como inserir um item em uma posição qualquer na lista. Para isso, usamos o método .insert(índice,
valor). Esse método insere o valor desejado diretamente na posição indicada e "empurra" os demais para as
posições posteriores.

>>> alunos = ['Joao', 'Pedro', 'Davi', 'Mateus', 'Miguel']

>>> print(alunos)

['Joao', 'Pedro', 'Davi', 'Mateus', 'Miguel']

>>> alunos.insert(3, 'Ana') # Insere 'Ana' na posição 3

>>> print(alunos) # insert() empurra os demais para posições posteriores

['Joao', 'Pedro', 'Davi', 'Ana', 'Mateus', 'Miguel']

Para apagar um item específico da lista, informando o valor em si, e não o índice, você pode usar o
método .remove(item). Note a diferença: no .pop(índice) você informa o índice da posição. No
método .remove(item), você informa o valor em si, não a posição.

>>> alunos.remove('Davi') # Remove 'Davi' da Lista

>>> print(alunos) # remove() puxa os demais para posições anteriores

['Joao', 'Pedro', 'Ana', 'Mateus', 'Miguel']

Um outro método importante é o .reverse( ). Ele inverte a ordem dos itens na lista.

>>> print(alunos)

['Joao', 'Pedro', 'Davi', 'Mateus', 'Miguel']

>>> alunos.reverse() # Inverte os itens da Lista

>>> print(alunos)

['Miguel', 'Mateus', 'Davi', 'Pedro', 'Joao']

Ainda há outro método a ser ensinado: o método .sort( ). Este método organiza a lista em ordem (alfabética ou
numérica). O jeito mais simples é simplesmente usá-la sem argumentos, como a seguir:

>>> print(alunos)

['Joao', 'Pedro', 'Davi', 'Mateus', 'Miguel']

>>> alunos.sort() # Ordena [alfabética] os itens da Lista

>>> print(alunos)

['Davi', 'Joao', 'Mateus', 'Miguel', 'Pedro']

Apenas um lembrete: uma lista pode conter dados com tipos diferentes (strings, integers e floats, por exemplo).
Uma lista pode até conter outras listas (veremos depois). Ou seja, cada posição de uma lista pode conter um
dado de tipo diferente, como, por exemplo: lista = [9, “casa”, True, 30+90, 3.4], que é formada por inteiro, string,
booleano e float, por exemplo.

Para finalizar, vamos conhecer o método .count(). Ele serve para contar quantas vezes um determinado valor
aparece numa lista. Veja o exemplo a seguir:

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 50

>>> genios = ['Mises', 'Hayek', 'Mises', 'Mises', 'Iorio', 'Iorio']

>>> genios.count('Mises')

Perceba que para usar o método .count(), você deve indicar o valor a ser contado dentro da lista genios. No
exemplo acima, pedi para contar quantas vezes 'Mises' aparece na lista genios.

11.2. O comando del

Uma outra forma de apagar um valor em uma lista é o comando del. Ele não é uma função ou método, mas um
comando simples que deve ser usado diretamente no código, apontando para qual item da lista deseja excluir,
veja o exemplo a seguir, que apaga o item de índice 2 da lista a:

>>> a = [1, 2, 3, 4, 5]

>>> del a[2] # Apagamos o item índice 2 da lista a

>>> print(a)

[1, 2, 4, 5]

Note como se escreve o comando del: del objeto_a_ser_apagado.

Outra diferença é que o comando del não retorna o valor do item apagado (como faz o método .pop()), ou seja,
esse comando simplesmente apaga o item.

O comando del não pode ser usado apenas para listas, não – ele pode ser usado com variáveis simples, também.
Se você aciona o comando del apontando para a variável em si (não somente uma posição dela), a variável inteira
deixará de existir e o Python não a reconhecerá mais. Isso pode ser constatado na próxima página.

>>> a = "Menger"

>>> del a # Apagamos a variável a inteira

>>> print(a)

Traceback (most recent call last):

File "<pyshell#77>", line 1, in <module>

NameError: name 'a' is not defined

Note que não foi possível imprimir na tela a variável a porque ela simplesmente não existe mais. É claro que o
comando del também pode ser usado para apagar uma lista inteira, não somente uma posição específica da lista.
Para isso, use del lista, como podemos perceber no código escrito na página seguinte:

>>> lista = [1, 2, 3, 4, 5, 6]

>>> del lista # Apagamos a lista inteira

>>> print(lista)

Traceback (most recent call last):

File "<pyshell#77>", line 1, in <module>

NameError: name 'lista' is not defined

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 51

Perceba que, depois de usar del lista, o objeto lista não existe mais, por isso não foi possível exibi-lo com o
comando print(lista).

11.3. O Teste de Pertencimento in

Um recurso muito interessante para listas e outros tipos de estruturas de dados múltiplos é o teste de
pertencimento: uma forma de testar se um determinado valor está dentro daquela lista ou não.

Usamos o operador in para fazer esse teste. O nome in é a mesma coisa que "em" em inglês. Portanto, ela serve
para testar se um determinado valor existe em uma determinada lista. Olha como funciona:

>>> lista1 = [1, 2, 3, 4, 5]

>>> print(4 in lista1) # testa se 4 está na lista1 e apresenta na tela o resultado

True # É verdade, ele está.

>>> print(8 in lista1) # testa se 8 está na lista1 e apresenta na tela o resultado

False # É falso, ele não está lá.

Note que ao mandar imprimir 4 in lista1, o resultado foi True: porque existe o valor 4 em lista1. Quando pedimos
para imprimir o resultado de 8 in lista1, o resultado foi False, porque não há 8 em lista1. O resultado de uma
expressão com in sempre é booleano!

11.4. Vamos Exercitar a Lição 11

O que será exibido na tela ao executar o código abaixo?

lista = [1, 5, 3, 4, 0, 2]

lista.pop(3)

lista.reverse()

a = lista[2] + lista[3]

lista.remove(5)

print(a + lista[3])

Aparecerá na tela:

Qual o conteúdo do objeto lista ao término do código a seguir?

lista = ['a', 'b', 'c', 'd']

lista.reverse()

lista.append('e')

lista.pop(2)

lista[0] = lista[3]

lista.remove('c')

lista = [ ]

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 52

Qual o conteúdo do objeto lista ao término do código a seguir?
lista = [1, 5, 9, 13, 17, 21, 25]

del lista[3]

del lista[1]

lista[1] = lista[3]

lista.remove(25)

lista = [ ]

Qual o conteúdo do objeto lista ao término do código a seguir?

lista = [1, 4, 9, 16, 25]

lista.append(36)

lista.append(49)

lista.append(64)

del lista[4]

lista.reverse()

lista[4] = lista[5]

lista[1] = lista[3]//2

lista.remove(1)

lista.pop(1)

lista = [ ]

Numa lista chamada numeros, posso afirmar que os comandos del.numeros[3] e

numeros.remove(3) realizam a mesma operação? Por quê?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 53

12. Vamos Exercitar Mais?
12.1. Programa para Preencher uma Lista com 5 Nomes
Estamos organizando uma lista contendo os nomes dos 5 participantes que a escola levará para as Olimpíadas
de Matemática. Para isso precisamos de um programa que peça ao usuário o nome de cada aluno escolhido e o
coloque em uma lista. Depois de inseridos todos os nomes, o programa irá imprimir a lista completa. Vamos
construir o programa?

alunos = [] # Isso cria uma lista vazia

nome = input("Digite o nome do aluno:") # Pegar o 1º Nome

alunos.append(nome)

nome = input("Digite o nome do aluno:") # Pegar o 2º Nome

alunos.append(nome)

nome = input("Digite o nome do aluno:") # Pegar o 3º Nome

alunos.append(nome)

nome = input("Digite o nome do aluno:") # Pegar o 4º Nome

alunos.append(nome)

nome = input("Digite o nome do aluno:") # Pegar o 5º Nome

alunos.append(nome)

print(alunos) # Imprime a lista inteira na Tela

Explicando o programa acima: o primeiro comando cria uma lista vazia (ou seja, sem itens) com o nome alunos.
Para fazer isso, atribua colchetes vazios ao nome da lista a ser criada.

No comando seguinte (na segunda linha), acontece um input (que pede dados ao usuário) e coloca esse dado
dentro da variável nome.

Na terceira linha, o conteúdo da variável nome é anexado na lista alunos (colocado no fim da lista, com o
método .append( )).

Nas linhas seguintes, repetem-se os atos de [a] pedir dado ao usuário; [b] guardar esse dado na variável nome e,
em seguida, [c] anexar (adicionar) o conteúdo da variável nome no fim da lista alunos.

Ao final deste programa, a lista é impressa na tela. Simples, né? O resultado do programa na tela será o seguinte:

Digite o nome do aluno: Joao

Digite o nome do aluno: Ana

Digite o nome do aluno: Pedro

Digite o nome do aluno: Mateus

Digite o nome do aluno: Miguel

['Joao', 'Ana', 'Pedro', 'Mateus', 'Miguel']

Agora é com você, ok?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 54

12.2. Programa para Juntar e Calcular 5 Números
Precisamos criar um programa para receber 5 números inteiros, calcule a soma e a multiplicação entre todos
eles e apresente, na tela: [a] a lista inteira, [b] a multiplicação entre eles e [c] a soma entre eles.

Dica: comece pensando quantas variáveis você vai precisar usar...

(Escreva o código aqui abaixo)

Tem mais aulas no meu Site: www.ProfessorJoaoAntonio.com.br

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 55

12.3. Programa para Juntar 6 Nomes e 6 Idades:
Que tal usar agora duas listas diferentes? Faça um programa que [a] peça um nome de seis pessoas; [b] peça a
idade das 6 pessoas; [c] armazene isso em duas listas diferentes [uma para nome e outra para idade].

Ao final do programa, imprima as 6 frases "<nome> tem <idade> anos."

(Escreva o programa aqui embaixo) – teste o código e/ou acompanhe o vídeo de correção.

Telegram: Bora trocar ideias no grupo do Telegram? @ProfessorJoaoAntonio.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 56

13. Mais Sobre Listas
13.1. Lista e Muitos Tipos
Uma lista pode ser preenchida com dados de diversos tipos diferentes, como strings, integers e floats. Uma lista
não exige que todos os seus dados sejam do mesmo tipo! Veja isso:

>>> dados = [3, 'Casa', 120, 2.34, 'Texto', 99, 8, 3.9]

>>> print(dados[4])

Texto

>>> print(dados[0]*dados[4])

TextoTextoTexto

13.2. Listas de Listas

Já que uma lista recebe vários tipos de dados, é fácil aceitar que uma lista poderá receber, inclusive, outras listas
como dados. Ou seja, é possível criar uma lista com várias listas dentro dela.

É normal chamar isso de "listas aninhadas" (nested lists, no inglês). Isso significa "uma lista funcionando como
'ninho' das outras". Veja o exemplo a seguir:

>>> lista_principal = [['a','b','c'],[1,2,3],['xx','yy','zz']]

>>> lista_principal.append([9,10,11])

>>> print(lista_principal)

[['a','b','c'],[1,2,3],['xx','yy','zz'],[9,10,11]]

Note que a lista_principal é uma lista composta por 4 listas. Ou seja, cada item da lista_principal é uma lista
diferente. Vamos "pintar" cada item para deixar mais fácil de entender:

[['a','b','c'],[1,2,3],['xx','yy','zz'],[9,10,11]]

Isso pode parecer um tanto "inútil" ou "estranho" agora, amigo leitor, amiga leitora... mas em breve veremos muita
utilidade para este recurso. Uma lista aninhada parece com isso aqui:

lista_principal

a b C
0
0 1 2

1 2 3
1
0 1 2

xx yy zz
2
0 1 2

9 10 11
3
0 1 2

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 57

A gente sabe que, para acessar um item de uma lista, a gente escreve nome_da_lista[índice]. Acontece que
apenas a lista principal (a lista-mãe) tem nome... as demais listas (as filhas) são itens da principal. Então, como
fazer para acessar, digamos, o item 'yy' do exemplo acima?

Bom, o item 'yy' está na posição 1 da lista que está na posição 2 da lista lista_principal. A forma para acessar
aquela exata posição é lista_principal[2][1], que significa "a posição 1 da posição 2 da lista_principal".

13.3. A função list( )

Já aprendemos como criar uma lista atribuindo a uma variável diretamente os valores (entre colchetes e
separados por vírgulas). Outra forma de criar uma lista é usar a função list( ). Quando a função list( ) é usada
assim, sem argumentos, ela cria uma lista vazia. Ou seja, escrever...

lista = list()

... é o mesmo que escrever...

lista = []

Podemos usar a função list( ) também colocando strings no argumento. Isso fará com que a lista seja criada tendo
cada caractere da string como um item. O exemplo a seguir mostra isso bem:

>>> lista = list('Mises')

>>> print(lista)

['M','i','s','e','s']

A lista pode ser criada, também, a partir de um objeto do tipo sequência (iterable, no inglês). Um objeto sequência
é um objeto formado por uma sequência numérica. A forma mais fácil de construir é por meio da função range( ).
Veja o exemplo a seguir (explico logo abaixo):

>>> seq = range(10) # Cria uma sequência de 0 a 10 (o 10 não é incluído)

>>> print(seq)

range(0, 10) # Este é um objeto sequência – de 0 [zero] a 10 [dez]

>>> seq2 = list(seq) # Transforma a sequência numa lista.

>>> print(seq2)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # Lista criada

Eu sei que você está estranhando que a lista só foi até o número 9. Não se preocupe: vou explicar direitinho na
lição sobre range().

13.4. Esvaziar uma Lista

Um outro método interessante para listas é o método .clear( ). Este método apaga todos os itens de uma lista,
deixando-a completamente vazia.

>>> lista = [1,2,3,4,5]

>>> lista.clear() # Neste momento, a lista foi esvaziada

>>> print(lista)

[]

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 58

13.5. Vamos Exercitar?
Observe o Código a seguir e responda às perguntas que se seguem a ele:

construtor = range(15)

lista = list(construtor)

lista.pop()

a = lista[3]+lista[4]

lista.reverse()

b = lista[4]+lista[5]

lista.append(lista[8])

c = len(lista)+lista[3]

d = a * b + c

Quais os valores das seguintes variáveis?

a= b= c= d=

Ainda sobre o código acima, descreva quais os resultados dos cálculos abaixo?

print(3 * a + len(lista) * 2)

print(4 * b + 60 % c)

print(max(lista) * len(lista) // 2)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 59

14. A Função range( )
14.1. Conhecendo a função range ( )
A função range( ) cria um objeto "iterável" (uma sequência). Para usar essa sequência como uma lista, converta-
a por meio da função list( ) – como vimos na lição anterior.

Dica: um objeto "iterável" é um objeto que pode ser criado por meio de um processo repetitivo (iterações) e que pode
ter cada um de seus itens acessados um a um em etapas. Uma sequência numérica construída pela função
range( ) é considerada um iterável pela linguagem Python.

A função range pode ser usada com um único argumento, como em

sequencia = range(10)

Neste caso, ele cria uma sequência de números inteiros que começa em 0 (zero) e vai até 9 (nove). O número
que é colocado como argumento é o "limite máximo" da sequência. O limite máximo da sequência NUNCA é
incluído na sequência, por isso que a sequência acima foi apenas até o número 9.

A função range( ) também pode ser usada com mais de um argumento, como aqui:

sequencia = range(3,10)

Do jeito como essa função foi escrita, ela criará uma sequência de 3 até 9. Não esqueça que o número limite
máximo (neste caso, o 10) nunca é incluído na sequência, mas o número inicial sempre é. Nesta sequência, com
início e fim, o primeiro argumento indica o início da sequência e o segundo argumento indica o número final (que
nunca é incluído).

A função range( ) também pode ser escrita com 3 argumentos. O primeiro indica o número de início, o segundo
indica o limite final e o terceiro indica a razão (os passos) entre cada item. Ou seja, o código

sequencia = range(3,10,2)

vai trazer uma sequência que começa em 3, vai até 9 (10 não é incluído) e salta de 2 em 2 a cada item, ou seja, a
sequência será 3, 5, 7, 9.

Para resumir, a função range( ) cria uma sequência de números inteiros e pode ser escrita:

range(final): a sequência começa em 0 (zero) e vai, de um em um, até final-1.

range(início, final): a sequência começa em início e vai, de um em um, até final-1.

range(início, final, passo): a sequência começa em início e vai, de passo em passo, até final-1.

É possível construir uma sequência decrescente (do maior para o menor). Basta que o início seja maior que o
final e que se escreva o passo negativo, como no exemplo:

>>> print(list(range(20,10,-2)))

[20, 18, 16, 14, 12]

14.2. "A Cara" da Função range( )

A função range( ) é conhecida como "construtora". Ela serve para construir uma sequência imutável de números
inteiros. Essa sequência não é uma lista, por isso não pode ser vista diretamente como uma lista. Vamos ver
como a função range( ) aparece?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 60

>>> a = range(3,20,4)

>>> print(a)

range(3,20,4)

Note que a variável a é mostrada como uma range, mesmo... não são apresentados os valores em si. Poderemos
ver os valores se pedirmos para ver a variável convertida para uma lista (usando a função list()):

>>> print(list(a))

[3, 7, 11, 15, 19]

Não esqueça: para poder "ver" e "mexer" numa sequência que foi criada pela função range(), devemos convertê-
la em uma lista, usando a função list() para isso.

14.3. Vamos Exercitar?

Descreva quais são as listas criadas a partir destas range( ):

list(range(20,30,3))

[ , , , ]

list(range(9))

[ ]

list(range(25,5,-4))

[ ]

list(range(7,23,2))

[ ]

list(range(37,13,-5))

[ ]

list(range(10,30,5))

[ ]

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 61

15. Brincando mais com Listas e Strings
15.1. Um pouco mais sobre índices
Strings e Lists são diferentes entre si e nós sabemos disso! String é um tipo de dado (um formato de aceitação
de dado) que pode ser manipulado pelo Python e List é uma estrutura de dados (um objeto capaz de receber e
armazenar dados diversos) que o Python entende.

Apesar de serem essencialmente diferentes, há muita coisa que podemos fazer em comum (e da mesma maneira)
em ambos. O uso de índices é uma delas:

a = "Mises" #Aqui, eu criei uma variável a contendo um string.

b = ['M', 'i', 's', 'e', 's'] # Aqui, eu criei uma lista chamada b

print(a[0])

print(b[0])

No código acima, estabelecemos que a variável a vai receber a palavra "Mises" e que a variável b vai receber a
lista composta pelas 5 letras da palavra "Mises". Os conteúdos são bem diferentes entre si, mas pedir para
mostrar na tela a[0], que significa apontar para a primeira letra da string "Mises" (portanto, para a letra "M") é o
mesmo que apontar para b[0], que faz referência ao primeiro item da lista b, ou seja, a letra "M" também.

Pra resumir, e nós já sabemos disso, cada letra da string pode ser acessada diretamente pelo seu índice, do
mesmo jeito que numa lista.

Índice Negativo

É possível usar, tanto em listas quanto em strings, uma referência a um índice negativo, como no exemplo

Nome_da_lista_ou_string[-2].

O que isso significa?

Bom, sabemos que listas e strings começam com índice 0 (zero), que representa o primeiro item da lista ou o
primeiro caractere de uma string. Veja a seguir um exemplo de uma variável chamada estado:

P E R N A M B U C O
0 1 2 3 4 5 6 7 8 9

Note que o item estado[4] aponta para a letra "A". Por sua vez, o item estado[8] aponta para "C".

Se usarmos índices negativos, a contagem começa no -1, a partir do último caractere ou item da lista, contando
para trás, como se pode ver a seguir:

P E R N A M B U C O
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1

Portanto, o item estado[-4] aponta para a letra "B" e o item estado[-8] aponta para "R".

15.2. Slices (Fatias)

Quando nós usamos variável[índice], estamos apontando para um único objeto, ou seja, estamos obtendo um
único resultado como resposta – seja um caractere, vindo de uma string, ou um único item, vindo de uma lista.

Podemos, porém, fazer uso de slices (a gente fala "isláicis", e quer dizer "fatias") para obter mais de um caractere
ou mais de um item de uma lista. É super fácil de usar! Veja o código a seguir:

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 62

 a = [1, 4, 9, 16, 25, 36, 49, 64]

b = a[2:5]

print[b]

Note que, em primeiro lugar, criamos uma lista a contendo 8 itens. Na segunda linha, pedimos para criar uma
lista b contendo uma "fatia" da lista a, que vai do item 2 até o item 5 (o sinal de "dois-pontos" é usado como "até").
Ao pedir para printar a lista b, o resultado será:

[9, 16, 25]

Peraí, João... se falamos "de 2 até 5", isso tem

que incluir, na listagem acima, os índices 2, 3,
4 e 5, ou seja, pegar o número 36 também!

Bem observado, amigo leitor! Mas aí é que tá... quando apontamos para [2:5], o índice final não é incluído na fatia
– lembram-se da função range( )? Do mesmo jeito que ela... também nas fatias, o último item não é incluído.

Então, se fizermos estado[3:7] no exemplo que usamos na página anterior, estamos apontando para:

P E R N A M B U C O
0 1 2 3 4 5 6 7 8 9
Note que ele inclui a posição 3, mas não inclui a 7, indo até a 6, apenas. Veja isso no Shell:

>>> a = "Pernambuco"

>>> b = a[3:7]

>>> print(b)

namb

Podemos pedir fatias "do 3 até o final" ou "do início até o 4" ou "do penúltimo até o final", usando alguns códigos
especiais antes e depois do dois-pontos, vejamos:

a = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

b = a[:5] # do início até o índice 4 (não inclui o 5)

c = a[6:] # do 6º item até o final

d = a[-3:] # do ante-antepenúltimo item até o final

e = a[:-4] # do início ao 4º - item contando a partir do final

Se quiser começar a slice a partir do início da lista ou string, simplesmente não coloque nada antes do sinal de
dois-pontos. Se quiser que a sua fatia vá até o final da lista ou string, não coloque índices após o sinal de dois-
pontos.

Ahhh, a propósito, as respostas para as variáveis mostradas no exemplo anterior são:

>>> print(b)

[1, 4, 9, 16, 25]

>>> print(c)

[49, 64, 81, 100]

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 63

>>> print(d)

[64, 81, 100]

>>> print(e)

[1, 4, 9, 16, 25, 36]

Comando del em Fatias

Você pode usar o comando del (que apaga variáveis) para apagar diversas posições de uma lista, basta que aponte
para o slice (fatia) desejado. Veja o exemplo abaixo:

>>> lista = [2, 4, 6, 8, 10, 12, 14, 16]

>>> del lista[2:5]

>>> print(lista)

[2, 4, 12, 14, 16]

Verifique que o comando del lista[2:5] só apagou os itens nas posições 2, 3 e 4 da lista. Porque, você já sabe, a
fatia 2:5 não inclui o item na posição 5 (nunca inclui o item na posição depois dos dois-pontos).

15.3. Listas são Mutáveis, Strings são Imutáveis

Uma diferença muito importante entre listas e strings é que no caso das listas, é possível mudar um item
específico (trocar o seu valor) acessando a posição certa por meio do índice. Não é possível, porém, fazer o
mesmo em relação a uma string. Não dá para alterar apenas um caractere específico numa string – por isso
dizemos que strings são imutáveis e listas são mutáveis (podem mudar).

texto = "Mises"

lista = ["M", "i", "s", "e", "s"]

lista[2] = "c" # Isso coloca "c" na posição 2 da lista

texto[2] = "c" # Isso vai dar um erro – é impossível fazer isso

Dá pra fazer, normalmente, a alteração do item 2 da lista lista. Mas não é possível alterar o caractere 2 da string
texto. Só dá para alterar a string toda, se uma só vez, nunca um caractere específico.

Não esqueça disso: é possível mudar uma posição específica de uma lista, basta acionar lista[posição] = valor.
Mas não dá para alterar uma posição específica de uma string (ou seja, não dá para alterar um caractere
específico de uma String) – por isso as strings são consideradas imutáveis!

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 64

15.4. Vamos Exercitar?

Analise o Código a seguir:

texto = "Pernambuco"

lista = [1, 10, 100, 1000, 10000, 100000]

fat1 = texto[:5]

fat2 = lista[-3:]

fat3 = texto[-6:-2]

fat4 = lista[1]

lista[0] = 20

texto[0] = "T"

Como resolver o problema no código acima digitando apenas um único caractere?

O que será impresso pelo comando print(fat1 * fat4)?

O que será impresso pelo comando print(fat3 * (lista[0]/10))?

O que será impresso pelo comando print(fat1[3:]*(fat4/2))?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 65

16. Tuplas
16.1. Sobre o que já sabemos...
A última lição nos mostrou as semelhanças entre as listas (estrutura de dados) e as strings (tipo de dados): ambas
admitem ser acessadas por meio de índices na forma de nome[índice] e também permitem o uso de slices no
formato nome[início:final].

Lembrando que listas são mutáveis (ou seja, podemos mudar um item específico nelas) e strings são imutáveis
(ou seja, não podemos alterar um item específico nelas por meio do acesso ao índice). Chegou a hora de
aprender sobre uma outra estrutura de dados: a tupla (tuple em inglês).

16.2. Conhecendo as Tuplas

Tupla é o nome dado a uma estrutura de dados parecida com a lista, mas que é imutável (ou seja, não dá para
modificar isoladamente um item de uma tupla). Para construir uma tupla, você pode atribuir a uma única variável
diversos valores separados por vírgulas. Você pode colocar os valores entre ( ) (parênteses) ou não (isso é
opcional).

nomes = 'Mises', 'Hayek', 'Rothbard', 'Beltrão', 'Iorio'

idades = (103, 98, 95, 51, 63)

Nas duas linhas mostradas acima, temos duas formas de criar tuplas: com e sem parênteses. O Python aceita as
duas formas de escrita! Não esqueça disso: quando atribuímos mais de um valor a uma única variável, essa
variável se torna uma Tupla!

Poxa, João, se uma Tupla é imutável, depois

de criada não dá para guardar novas
coisas nela, né? Para que ela serve, então?

Excelente pergunta! Uma tupla é usada quando precisamos de uma estrutura "somente-leitura", ou seja, de um
espaço na memória onde só é possível consultar os dados já guardados, e não modificá-los – acredite em mim,
amigo leitor: vão acontecer casos em que é necessário, sim, usar estruturas para "somente leitura".

Uma tupla não pode ter itens apagados, nem adicionados, nem modificados... Se ela nasceu com 5 itens, ela vai
existir sempre com aqueles 5 itens! Nunca serão apagados, nunca serão modificados, não será possível adicionar
novos itens na tupla.

16.3. Como Criar uma Tupla vazia?

Apesar se ser algo aparentemente inútil, é possível criar uma Tupla vazia, basta escrever:

t1 = ()

Também é possível criar uma tupla com um único item dentro dela, mas para isso é necessária atenção especial
de sua parte, amigo leitor! Para criar uma tupla com um único item, você deve escrever o item e uma vírgula
depois dele, caso contrário o Python entenderá que você quer criar uma variável simples, olha só:

t1 = (1,) # Isso é uma tupla com apenas o elemento 1

t2 = 2, # Isso é uma tupla com apenas o elemento 2

t3 = (1) # Isso é uma variável contendo um inteiro 1, apenas.

t4 = 2 # Isso é uma variável contendo apenas o inteiro 2

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 66

Depois de criar uma tupla, como você bem sabe, não é possível alterar nenhum de seus itens.

16.4. O que podemos Fazer com Tuplas, então?

As operações básicas que podemos realizar com Tuplas são:

Exibir o tamanho da Tupla

Podemos exibir o tamanho (comprimento) da Tupla usando a função len( ), conforme vemos no exemplo a seguir:

>>> tupla1 = (2, 4, 6, 8, 10, 12, 14, 16)

>>> print(len(tupla1))

A tupla1 tem 8 elementos e usar a função len( ) nela resultará no número 8.

Concatenar Tuplas

É possível unir duas ou mais tuplas em uma única (uma nova tupla). Para isso, basta usar o operador + (sinal de
mais). Veja o exemplo a seguir:

>>> t1 = 1, 2, 3

>>> t2 = 4, 5, 6

>>> t3 = t1 + t2

>>> print(t3)

(1, 2, 3, 4, 5, 6)

Note: não houve alteração em nenhuma tupla (já que não é possível alterá-las). Houve apenas a criação de uma
terceira tupla chamada t3 a partir das duas anteriores (t1 e t2).

Repetir Tuplas

Uma tupla pode ser repetida por meio do operador * (asterisco), exatamente como fazendo com strings. Veja o
exemplo a seguir:

>>> t1 = 1, 2, 3

>>> t2 = t1 * 3

>>> print(t2)

(1, 2, 3, 1, 2, 3, 1, 2, 3)

Note que os itens da tupla t1 foram multiplicados por 3 para criar a tupla t2. Não houve alteração na tupla t1.

Teste de Pertencer

É possível testar se um item pertence, ou não, a uma tupla, usando o operador in ("em" em portugês), exatamente
como usamos em listas. Veja a seguir:

>>> t1 = 1, 2, 3, 4, 5

>>> print(4 in t1)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 67

True

>>> print("4" in t1)

False

Ao pedir para printar 4 in t1, obtemos o resultado True, porque o 4 existe em t1. Quando pedimos para mostrar
"4" in t1, a resposta é False porque não existe "4" (string) dentro de t1.

16.5. Vamos Exercitar Tuplas

Quais os resultados dos programas abaixo mostrados na tela?

t1 = 2, 4, 6, 8

t2 = (1, 3, 5, 7, 9)

t3 = t1 + 2 * t2

print(len(t3)*t1[1])

print(t2[1]*2 in t3)

t1 = 'Joao', 'Ana', 'Pedro', 'Mateus'

t2 = 4, 3, 2, 1

variavel = t1[t2[1]]*t1[0]

print(variavel)

t1 = "Pernambuco", "Caruaru", "Recife", "Gravatá"

t2 = 3, 5, 1, 2

t1[3] = t2[2]

t5 = (1, 2, 3, 4, 5)

t6 = (6, 7, 8, 9)

t5 = t5 + t6

print(t5[0] + t5[5])

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 68

17. Semelhanças entre Tuplas e Listas
17.1. O Porquê desta Lição
Como Tuplas e Listas são muito parecidas, resolvi trazer algumas comparações entre essas duas estruturas de
dados, mostrando, inicialmente, as principais...

17.2. Semelhanças entre Tuplas e Listas

Criando Listas e Tuplas

Listas e Tuplas são objetos com vários conteúdos [chamados de "estruturas de dados"] e, por isso, admitem
receber vários itens. Para identificar esses vários itens, separamos eles por vírgulas.

Tuplas podem ser criadas com os itens separados por vírgulas diretamente ou por eles envolvidos por
parênteses. Listas são criadas com vários itens separados por vírgulas envolvidos por colchetes.

e1 = 1, 2, 3, 4 # Isso cria uma TUPLA

e2 = (1, 2, 3, 4) # Isso também cria uma TUPLA

e3 = [1, 2, 3, 4] # Isso cria uma LISTA

Para criar listas e tuplas vazias, basta criar a variável atribuindo colchetes ou parênteses vazios:

e4 = () # Isso é uma TUPLA vazia

e5 = [] # Isso é uma LISTA vazia

Para criar uma lista com apenas um elemento, atribua à variável o valor entre colchetes (apenas isso). Para criar
uma tupla com um único elemento, deve-se atribuí-lo seguido da vírgula para evitar que o Python entenda errado
(como vimos na lição anterior):

e6 = (1,) # Isso é uma TUPLA contendo apenas o inteiro 1

e6 = 1, # Isso é uma TUPLA contendo apenas o inteiro 1

e7 = [1] # Isso é uma LISTA contendo apenas o inteiro 1

Não esqueça: Listas e Tuplas podem conter diversos tipos de dados diferentes: Strings, Inteiros, Floats,
Booleanos etc., conforme o exemplo a seguir:

lista1 = [1, 2, "a", 3, "c", True, 4, 8.7]

tupla2 = (1, 2, "c", 4, False, True, 5, "20", 14.9)

Apagando Listas e Tuplas

O comando del pode ser usado tanto em Tuplas quando em Listas (e também é usado em variáveis comuns do
mesmo jeito). Este comando apaga o objeto em questão retirando-o definitivamente da memória do computador.
Ou seja, o objeto apagado pelo del deixa de existir.

t1 = 1, 2, 3, 4

l1 = [1, 2, 3, 4]

v1 = "texto"

del t1, l1, v1 # Este comando apaga as três estruturas

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 69

Acessando Posições das Listas e Tuplas

Tanto em tuplas quando em listas, é possível acessar uma posição específica da estrutura por meio do uso do
índice. Usa-se o nome da variável seguido do número da posição entre colchetes.

>>> t1 = "Mises", "Hayek", "Hoppe", "Menger", "Bohm-Bawerk"

>>> l1 = ["Mises", "Hayek", "Hoppe", "Menger", "Bohm-Bawerk"]

>>> print(t1[3])

"Menger"

>>> print(l1[0])

"Mises"

Também é possível acessar os itens de uma lista ou tupla por meio de índices negativos, que começam do -1, que
é o último item da lista/tupla.

>>> print(t1[-3])

"Hoppe"

>>> print(l1[-1])

"Bohm-Bawerk"

Também é possível fazer slices (fatias) apontando para alguns itens usando o operador : (dois-pontos) tanto em
listas como em tuplas.

>>> print(t1[1:4])

('Hayek', 'Hoppe', 'Menger')

>>> print(l1[-3:-1])

['Hoppe', 'Menger']

Concatenando Tuplas e Listas

É possível concatenar Tuplas e Listas, basta usar o operador + (sinal de mais). O resultado é uma lista/tupla com
a soma dos elementos das duas ou mais originais:

>>> l1 = [1,2,3,4]

>>> l2 = [4,5,6,7]

>>> print(l2+l1)

[4, 5, 6, 7, 1, 2, 3, 4] # A saída é uma lista [claro!]

>>> t1 = (1,2,3,4)

>>> t2 = 4,5,6,7

>>> print(t2+t1)

(4, 5, 6, 7, 1, 2, 3, 4) # A saída é uma tupla [óbvio!]

Não dá para concatenar uma tupla com uma lista. Só é possível concatenar estruturas de dados de mesmo tipo.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 70

Teste de Pertencimento

É possível usar o operador in para testar se um determinado item está numa lista ou tupla.

>>> l1 = [1, 2, 3, 4, 5, 6]

>>> t1 = 1, 2, 3, 4, 5, 6

>>> print(2 in t1)

True

>>> print(4 in l1)

True

Funções usadas em Listas e Tuplas

Há ainda algumas funções que podemos usar tanto em listas quanto em tuplas. Vamos listá-las agora para você,
amigo leitor, amiga leitora:

Função Descrição

len(sequência) Retorna o tamanho (comprimento) da sequência (tupla ou lista). Ou seja, retorna

o número de itens do objeto.

max(sequência) e Retornam o maior (max) e o menor (min) valor dentro da sequência (seja ela uma
min(sequência) tupla ou lista)

tuple(sequência) Converte uma sequência (lista ou range( )) em tupla.

list(sequência) Converte uma sequência (tupla ou range( )) em lista.

sum(sequência) Retorna a soma dos itens numéricos da lista ou tupla.

sequência.count(valor) Retorna a contagem (quantidade de ocorrências) do valor dentro da sequência

(tupla ou lista).

sequência.index(valor) Retorna o índice (posição) do valor encontrado dentro da sequência (tupla ou

lista).

lista.sort() Ordena os itens (ordem crescente) de uma lista (não funciona com tuplas).

lista.reverse() Inverte a ordem dos itens de uma lista (não funciona com tuplas).

lista.append(valor) Adiciona o valor na última posição de uma lista (não funciona com tuplas).

lista.extend(sequência) Adiciona a sequência [itens] no final de uma lista (não funciona com tuplas).

lista.remove(valor) Remove o valor de uma lista (não funciona com tuplas).

lista.clear() Esvazia a lista (não funciona com tuplas).

Os últimos seis comandos/funções/métodos mostrados acima não funcionam com tuplas porque eles alteram a
estrutura de dados, e tuplas não podem ser modificadas (lembra disso, né?).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 71

17.3. Vamos Exercitar?

Qual o resultado na tela dos códigos a seguir?

lista = []

lista.append(1)

tupla = 1, 2, 3, 4, 5, 6, 7

for i in tupla:

lista.append(i)

tupla = list(tupla)

print(lista == tupla)

tupla = (3)

variavel = 3

lista = [1, 2, 3]

lista = lista * variavel

tupla = tupla * variavel

print(lista)

print(tupla)

tupla = [8, 0, 9, 3]

variavel = 2

lista = (1, 2, 3)

lista = list(lista)

tupla = tuple(tupla)

tupla = variavel * lista

print(tupla + lista)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 72

18. Dictionaries (Dicionários)
18.1. Pequena Apresentação
Um Dictionary (Dicionário) é uma estrutura de dados para receber múltiplos valores (como uma lista ou uma
tupla), porém, são mais complexas que elas. Um dicionário é formado por vários elementos, e cada um desses
elementos é formado por uma dupla de informações que chamamos de Chave e Valor.

Dicionários armazenam dados dentro dessas duplas. Os dados armazenados são os valores e a forma de
encontrar esses valores são justamente as chaves. O acesso aos dados não é feito por meio de índices, mas por
meio das chaves.

18.2. Criando Dicionários

Para construir um dicionário, você escreve assim:

dicio = {'Nome':'João', 'Idade': 45, 'E-mail': '[email protected]'}

Note que o Dicionário é envolvido por chaves (o nome desses símbolos: { }) e cada elemento da listagem é
composto de chave : valor (separados pelo sinal de : - dois-pontos) e os elementos são separados, entre si, por
vírgulas, como nas listas e tuplas. Os valores de um dicionário são mutáveis, podem ser alterados livremente,
mas as chaves que apontam para eles têm que ser imutáveis, como uma string, um número ou uma tupla.

Para acessar um determinado elemento num dicionário, é necessário apontar para o nome do dicionário seguido
do nome da chave [entre colchetes] do elemento desejado. Assim:

print(dicio['Nome'])

Perceba que este código aponta para a chave 'Nome' dentro do dicionário dicio. O resultado deste código é bem
simples: ele retorna o valor associado à chave 'Nome', ou seja:

'João'

Um dicionário é, portanto, uma estrutura de dados que se assemelha a algo assim:

Nome Idade E-mail

João 49 [email protected]

Para criar um dicionário vazio, é suficiente atribuir { } (abrir e fechar chaves) ao nome do dicionário que se deseja
criar. Acho que você já tinha deduzido, né? É muito semelhante a listas e tuplas:

dicionario_vazio = {}

18.3. Alterando Valores dos Itens num Dicionário

Para alterar Valores em um dicionário, basta atribuir um valor novo a uma chave já existente. Ou seja, para mudar
o valor da chave Idade, é só fazer isso:

dicio['Idade'] = 50

print(dicio)

O resultado disso é:

{'Nome': 'João', 'Idade': 50, 'E-mail': '[email protected]'}

Perceba que o valor associado à chave 'Idade' foi alterado.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 73

18.4. Criando um Novo Elemento no Dicionário
Para criar itens novos, basta atribuir valores a chaves que ainda não existem – essas chaves serão criadas e
preenchidas com o valor que você está inserindo agora. Por exemplo, olha o código a seguir:

dicio['Telefone'] = '98213-2325'

O dicionário agora contém isso:

{'Nome': 'João', 'Idade': 50, 'E-mail': '[email protected]', 'Telefone': '98213-2325'}

Ou seja, nosso dicionário passou a ser semelhante a esta tabela:

Nome Idade E-mail Telefone

João 50 [email protected] 98213-2325

18.5. Apagando Elementos do Dicionário

Para apagar um elemento de um dicionário, use o comando del. Veja um exemplo:

del dicio['E-mail'] # Aqui o elemento da chave 'E-mail' foi apagado

print(dicio)

O resultado deste código é:

{'Nome': 'João', 'Idade': 43, 'Telefone': '98213-2325'}

Note que o elemento que possuía a chave 'E-mail' foi excluído do dicionário. Para apagar o dicionário inteiro (não
somente um elemento específico), é só usar del dicio (isso destrói o dicionário inteiro).

Também é possível "esvaziar" um dicionário (apagar todos os seus elementos, mas deixar o dicionário existindo
vazio, sem itens), para isso usamos o método .clear( ).

dicio.clear() # Aqui o dicio foi esvaziado

print(dicio)

Esse código resultará em:

{}

18.6. Chaves Duplicadas?

Um dicionário não aceita mais de um elemento com a mesma chave. Se um dicionário for criado com dois
elementos com a mesma chave (mesmo nome), apenas o posterior ficará (não é o primeiro que vai ficar, é o
último). Veja esse exemplo:

dic = {1: "Mises", 2: "Hayek", 3: "Menger", 2: "Rothbard", 3: "Hoppe"}

Note que há dois elementos com a chave 2 e dois elementos com a chave 3. Isso vai resultar em:

{1: "Mises", 2: "Rothbard", 3: "Hoppe"}

O elemento 2:"Hayek" e o elemento 3:"Menger" foram desconsiderados, sendo mantidos apenas os outros dois
posteriores com as chaves 2 e 3. Ou seja, “os últimos substituirão os primeiros!” (amém?)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 74

18.7. Para que servem os Dicionários?
Em ambientes de programação web (sites, apps, nuvem), é muito comum usar uma linguagem de troca de dados
chamada JSON (Javascript Object Notation), JSON é usada para permitir a transferência de dados entre
aplicativos diferentes, pois é uma linguagem que todos os programas conseguem ler.

Eis um exemplo de registro de dados em formado JSON:

{"nome": "João", "idade": 30, "cidade": "Caruaru"}

Percebeu algo? Sim! O formato dos dados em JSON é exatamente igual ao formato da estrutura que conhecemos
como dicionário no Python. (bom, há algumas diferenças pequenas, mas abordaremos isso mais adiante)

Por ora, é bom saber que, se você vai criar um programa que será usado na Internet, junto com um site, um app,
por exemplo, e você sabe que vai usar JSON para transmitir os dados entre eles, saiba que você vai usar
dicionários em seu programa Python!

18.8. Vamos Exercitar?

Qual o resultado do código abaixo?

lista = []

dicio = {}

seq = range(10)

for i in seq:

lista.append(i*2)

dicio[i] = i**2

lista.reverse()

lista.pop()

lista.remove(10)

del dicio[3]

# print(lista)

# print(dicio)

print(lista[4] * dicio[2] - 2)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 75

19. A Estrutura de Repetição for
19.1. Pra que serve e Como usar a for?
Na lição 12, fomos apresentados a inúmeros programas que exigiam várias vezes a mesma coisa (como pedir o
nome ou a idade do usuário). Naquele momento, fizemos vários exemplos escrevendo todas as vezes os mesmos
comandos no código. Por exemplo: imagina se o programa tiver que pedir três vezes que o usuário digite os
nomes dos alunos e depois adicionar esses nomes numa lista... como ficaria?

lista = []

nome = input("Digite o nome do aluno:") #Pedimos uma vez.

lista.append(nome) #Adicionamos uma vez.

nome = input("Digite o nome do aluno:") #Pedimos de novo.

lista.append(nome) #Adicionamos de novo.

nome = input("Digite o nome do aluno:") #Pedimos outra vez.

lista.append(nome) #Adicionamos outra vez.

É um saco, né?

Tem um jeito bem simples de fazer um (ou mais) comando(s) ser(em) repetido(s) sem precisar escrever todo o
código mais de uma vez. São as chamadas estruturas de repetição – ou laços de repetição. O primeiro laço de
repetição que iremos conhecer é o laço for.

O laço for é usado quando nós sabemos quantas vezes os comandos serão repetidos, pois precisamos informar
isso ao usá-lo. Usamos o laço for da seguinte maneira:

for x in range(1,6):

print(x)

Note que a segunda linha está um pouco afastada da margem esquerda. Esse efeito é chamado de indentação
(recuo). Para a linguagem Python, a indentação é muito importante – Você simplesmente não pode errá-la,
porque o programa simplesmente não funcionará!

A indentação informa que todo o código recuado está dentro da linha de código anterior, ou seja, a linha print(x)
está dentro do laço for num in range(1,6):.

Vamos entender o que significa este código? for num in range(1,6) pode ser lido como para cada <num> dentro
da sequência 1 a 6 [sem o 6]... ou seja, o Python vai:

[A] Criar uma variável temporária chamada num (qualquer nome serve);

[B] Atribuir à variável num o valor do primeiro item da sequência (no caso, o número 1);

[C] Realizar os comandos dentro do laço (no caso, printar na tela o valor de num);

[D] Atribuir à variável num o valor do próximo item da sequência;

[E] Realizar os comandos dentro do laço para este valor;

[F] Repetir os passos [D] e [E] até o final da sequência.

O resultado do código anterior é:

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 76

1

Podemos traduzir o programa acima em "português" (para que fique fácil entender) como:

Para cada num em range(1,6):

mostre num na tela

A sintaxe (regra de escrita) correta do laço for é:

for variável in sequência:

comandos a serem repetidos

comandos a serem repetidos

comandos a serem repetidos

Este comando já não faz mais parte do laço

Para indicar o final de um laço qualquer, é só escrever algum comando sem a indentação dos demais. Não
esqueça, também, de colocar o sinal de : (dois pontos) no final do comando que estabelece o laço for.

Vamos ver outro exemplo de programa com o laço for:

for base in range(0,5):

print("O quadrado de", base, "é", base ** 2)

print("O cubo de", base, "é", base ** 3)

Este código vai repetir dois comandos print a cada passo da iteração. O resultado dele é:

O quadrado de 0 é 0

O cubo de 0 é 0

O quadrado de 1 é 1

O cubo de 1 é 1

O quadrado de 2 é 4

O cubo de 2 é 8

O quadrado de 3 é 9

O cubo de 3 é 27

O quadrado de 4 é 16

O cubo de 4 é 64

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 77

19.2. Usando o laço for com Listas
O laço for pode ser construído com listas também, desta forma, a variável temporária usada no comando é
preenchida diretamente com os valores da lista, um a um, a cada passo.

Vamos ver um exemplo?

economistas = ['Mises', 'Hayek', 'Rothbard', 'Iorio', 'Barbieri']

for nome in economistas:

print("Menos Marx, Mais", nome)

Este programa retorna:

Menos Marx, Mais Mises

Menos Marx, Mais Hayek

Menos Marx, Mais Rothbard

Menos Marx, Mais Iorio

Menos Marx, Mais Barbieri

19.3. Vamos Exercitar?

Construa um programa que apresente na tela o triplo de cada número de 1 a 10.

Construa um programa que imprima na tela todas as letras do alfabeto (cada letra sendo
impressa numa linha diferente).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 78

20. A Estrutura de Repetição while
20.1. Conhecendo o Laço while
Aprendemos, na lição passada, sobre a estrutura de repetição for. Ela é muito útil para conseguir repetir
comandos quando sabemos exatamente o número de vezes que esses comandos serão repetidos.

Mas há alguns casos em que vamos ter que pedir para repetir sem saber quantas vezes temos que fazê-lo. Para
esses casos, o laço for não funciona, temos que usar o laço while (significa "enquanto" em inglês e se fala
mineiramente “uáiôu”).

A gente usa ele assim:

while condição:

faça isso

faça isso

faça isso

aqui não faz mais parte do laço while

Note que a parte principal do laço while é a sua condição – uma proposição ser verdadeira. Para que o laço
while seja executado (ou seja, que os comandos dentro dele sejam executados), basta que a proposição lá em
cima seja verdadeira.

Vamos analisar um código bem simples:

contador = 1

while contador <= 5:

print(contador)

contador += 1

Neste programa:

[A] Começamos definindo que a variável contador tem valor 1.

[B] Estabelecemos que enquanto contador for menor ou igual a 5, os comandos abaixo serão repetidos.

[C] O programa irá imprimir [na tela] o valor atual da variável contador.

[D] O programa irá somar 1 à variável contador [explicação abaixo].

[E] O programa volta a analisar a condição do while lá em cima, se ela continuar verdadeira, o programa
executará os comandos internos ao while novamente.

Atenção: a expressão contador += 1 é uma forma reduzida de escrever contador = contador + 1. (lembra disso,
né?)

Atenção 2: é necessário colocar algum comando, dentro do laço while, para atualizar a variável analisada na
condição. Sem esse comando, o valor da variável contador será sempre 1 (conforme definido antes do laço
começar), o que fará o while ser eterno (repetir eternamente os comandos porque a condição será sempre
verdadeira, o que chamamos de Loop Infinito).

O resultado do programa mostrado acima é mostrado na próxima página:

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 79

1

20.2. Loop Infinito

Quando é criado um laço de repetição que não tem como parar, ou seja, que vai se repetir para sempre, chamamos
isso de Loop Infinito. Às vezes, o Loop Infinito é um erro, uma falha... e, portanto, deve ser corrigido. Outras vezes,
porém, é necessário fazer um loop infinito que ofereça alguma forma de sair dele em caso de emergência.

Vamos avaliar um pequeno código com erro de loop infinito:

senha = 1

while senha <= 5:

print("a senha é:", senha)

Note que em nenhum momento foi incluído um comando que altera o valor da variável senha. Ela ficará sempre
com valor 1. Como o valor 1 é menor ou igual a 5, então a proposição senha <= 5 será sempre verdadeira. Esse
while não terá fim... ele vai repetir eternamente o comando print, resultando em:

a senha é: 1

a senha é: 1

a senha é: 1

a senha é: 1

a senha é: 1

a senha é: 1

E assim por diante... pra sempre! Se não é o seu desejo que isso aconteça, nunca esqueça de incluir a cláusula
que altera o valor da variável que é usada como condição do laço while.

A gente resolve isso colocando alguma linha,

dentro do laço while, que incremente a variável
senha, não é, João? Tipo senha = senha+1...

Exatamente, caro leitor! É tão simples evitar o erro do loop infinito... basta lembrar de colocar uma linha que
incremente variável que o while analisa. O for não precisa disso (ele a incrementa automaticamente), mas o while
não é tão “esperto” assim.

20.3. A cláusula else

O laço while repetirá comandos enquanto a sua condição (proposição) for verdadeira. Mas e quando não for mais?
Bom, quando uma condição deixa de ser verdadeira, o programa simplesmente deixa de repetir o laço e passa a
executar o primeiro comando após o laço (fora dele).

Existe a possibilidade de adicionar uma cláusula chamada else (senão, em inglês) que faz o Python obedecer
quando a condição do laço while não for mais verdadeira. Veja o código a seguir:

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 80

 a = 1

while a < 4:

print(a)

a += 1

else:

print("acabou a repetição")

print("fim do programa")

O resultado do programa será:

acabou a repetição

fim do programa

No final das contas, a cláusula else nem é tão importante assim porque quando a condição da while for falsa, o
laço deixará de ser executado [repetido] e o próximo comando [imediatamente abaixo e fora do while] já vai ser
executado.

20.4. while True

Uma forma mais fácil de fazer um Loop Infinito (se necessário) é usar o laço while com a condição True. Lembre-
se de que True é um valor booleano e significa Verdadeiro, portanto, é imutável, será considerado sempre
verdadeiro.

while True:

print("sempre")

Esse código simples vai imprimir a palavra "sempre" infinitas vezes porque a condição do while é True.

20.5. Diferenças Cruciais entre for e while

Os dois são laços de repetição, mas os dois apresentam algumas diferenças:

Laço for Laço while

Sua variável de controle é declarada na própria linha Sua variável de controle deve ser declarada e ter valor
do laço for (for x in sequência). atribuído antes da linha do laço while.

Sua variável de controle é incrementada Sua variável de controle deve ser incrementada por
automaticamente ao retornar à linha do laço for. uma linha de código dentro do laço, na posição que for
mais conveniente.

O laço for será repetido um certo e definido número de O laço while será repetido um número incerto de
vezes (descrito na própria sequência da linha que vezes, enquanto a condição for verdadeira.
determina o laço em si).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 81

20.6. Vamos Exercitar o Laço while?

Construa um programa que solicite vários nomes dos usuários e os guarde numa lista até que
o usuário digite "fim". Depois de finalizar a captura dos nomes, o programa irá exibir a lista
contendo todos os nomes inseridos pelo usuário.

Construa um programa que solicite diversos preços ao usuário. O programa deve entender
que o número 0 [zero] indicará o fim da captura dos dados. Ao término da captura de todos
os números, o programa deverá realizar a soma de todos os preços capturados.

Tens Instagram? Me segue lá! @ProfessorJoaoAntonio.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 82

21. Estrutura Condicional if
21.1. Conceitos básicos do if
Algumas vezes, é necessário fazer com que o próprio programa "decida" por seguir um caminho ou outro. Este
caso é resolvido com uma estrutura muito conhecida chamada if ("se", em inglês). A cláusula if é usada assim:

if proposição:

faça isso

faça isso

faça isso

aqui já não faz mais parte do if

Novamente, de forma bem semelhante ao laço while, a condição para que o if aconteça é uma proposição ser
verdadeira. Se ela for verdadeira, todos os comandos dentro do if serão obedecidos uma vez. Se a proposição
não for verdadeira, nenhum comando dentro do if será executado (ou seja, o bloco inteiro será ignorado).

Vejamos:

senha = 20

if senha > 10: # SE a variável senha for maior que 10 [e ela é]...

print("A senha é:", senha) # ...este código será executado

print("Fim do Programa")

O resultado deste código é:

A senha é: 20

Fim do Programa

Note o código abaixo, em que a variável senha não é maior que 10 inicialmente:

senha = 5

if senha > 10:

print("A senha é:", senha) #Este código será ignorado

print("Fim do Programa")

O resultado deste código é:

Fim do Programa

Ou seja, neste exemplo, o código que existe dentro do laço if não foi executado porque a condição (a senha ser
maior que 10) não era verdadeira.

Ou seja, João... a estrutura if

pode simplesmente nem ser
executada uma vez... né?

Exatamente, caro leitor! Se a condição inicial for falsa, os comandos dentro do if são ignorados.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 83

21.2. Cláusula else
A estrutura if também tem a sua cláusula else, e funciona melhor aqui. Os comandos presentes dentro do bloco
else só serão executados caso a condição do if seja falsa. Caso a condição da if seja verdadeira, os comandos
dentro da else não serão executados.

Vamos a um exemplo:

senha = 5

if senha > 10: #Esta condição é FALSA

print("A senha é:", senha) #Este código será ignorado

else:

print("A senha é menor que 10!") #Este código será executado

print("Fim do Programa")

O resultado deste código é:

A senha é menor que 10!

Fim do Programa

Note que o bloco dentro do if foi ignorado e apenas o bloco dentro do else foi executado.

21.3. Cláusula elif

A cláusula elif é usada quando você precisa fazer outro teste (além do teste do if) antes de partir para o uso de
uma cláusula else.

Um exemplo que sempre usam para ilustrar isso é sobre uma nota escolar. Vamos supor que a regra é essa: [a]
se tirar nota menor que 5, está "reprovado". [b] se não tirar menos que 5, mas tirar menos que 7, vai para a "prova
final". [c] se tirar 7 ou mais, ele estará automaticamente aprovado.

Dica: vale lembrar que a cláusula elif é uma contração de else if ("senão, se", em inglês).

O código a seguir mostra como seria feito um programa para a regra acima:

nota = float(input("Digite a nota do aluno:"))

if nota < 5:

print("O aluno está REPROVADO")

elif nota < 7:

print("O aluno vai para a PROVA FINAL")

else:

print("O aluno está APROVADO")

print("Fim do Programa")

Perceba que if, elif e else devem ter exatamente a mesma indentação (ou seja, o mesmo afastamento da margem
do editor).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 84

Explicando o código acima:

[A] Pede-se que o usuário digite a nota do aluno [função input( )] e converte-se o que ele digitar em um
número float [função float( )], armazenando isso na variável nota.

[B] Inicia-se o teste if para saber se nota é menor que 5. Caso isso seja verdade, apresenta-se na tela a frase
"O aluno está REPROVADO".

[C] Caso este teste anterior seja falso [ou seja, a nota não é menor que 5], inicia-se outro teste [elif], agora
para saber se a nota é menor que 7. Caso isso seja verdade, apresenta-se na tela a mensagem "O aluno
vai para a PROVA FINAL".

[D] Caso o teste anterior também seja falso [ou seja, se a nota não for menor que 7], resta obedecer à cláusula
else, apresentando na tela a mensagem "O aluno está APROVADO".

21.4. Vamos Exercitar o if?

Escreva um programa que receba vários nomes e idades de usuários e os adicionem a uma
lista caso eles sejam maiores de idade [18 anos ou mais velho] e os adicionem a outra lista
caso eles sejam menores de idade [menor de 18 anos].

Escreva um programa que receba vários nomes e vários códigos de modalidades esportivas:
"f" para Futebol, "b" para Basquete e "v" para Vôlei. O programa deverá colocar os alunos
em listas separadas de cada modalidade. Ao final do programa, deve ser informado se a
equipe foi completada (5 jogadores para Basquete, 11 para Futebol e 6 para Volei).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 85

22. Caracteres Especiais nas Strings
22.1. Por que Caracteres Especiais?
Em alguns casos, podemos precisar apresentar sinais (símbolos) especiais nas strings que apresentamos na tela
para o usuário. Um exemplo simples é o caractere das aspas. Como poderíamos apresentar o caractere das aspas
para os usuários? Que tal assim:

print("Que tal apresentar "aspas" para o usuário?")

Note que a linha acima apresentará um problema, porque as segundas aspas (as " depois de apresentar) serão
entendidas como sendo o fechamento das primeiras... Isso porque a função print() a entenderá assim. Ela não
será apresentada como eu gostaria que fosse:

Que tal apresentar "aspas" para o usuário?

Se você quer, realmente, mostrar aspas no texto que aparecerá para o usuário, você deve usar um código
interessante no Python... esse aqui:

print("Que tal apresentar \"aspas\" para o usuário?")

O símbolo de \" (barra-invertida seguido de aspas) é o indicador de um caractere especial. Ele é a forma de dizer
ao Python que as aspas que seguem a barra-invertida devem ser apresentadas exatamente daquele jeito na saída
– ou seja, as aspas não serão consideradas parte do código do print(), e sim, aspas dentro do texto. Há outros
exemplos de caracteres especiais que usam a barra-invertida.

A combinação \' [barra-invertida com aspas simples] é usada para apresentar uma aspas simples (também
chamada de apóstrofo) no texto.

print("Vamos apresentar um \'apóstrofo\' no texto")

resulta em:

Vamos apresentar um 'apóstrofo' no texto

A combinação \t (barra-invertida com a letra t) serve para colocar uma tabulação horizontal naquela posição
na linha (que é aquele espaço criado pelo uso da tecla TAB).

print("NOME \t FONE \t IDADE")

print("Joao \t 9876-5432 \t 42")

resulta em:

NOME FONE IDADE

Joao 9876-5432 42

A combinação \t é usada para a organização visual dos dados na tela do usuário. É possível colocar mais de um
\t seguidamente, para aumentar os espaços entre os dados. Seria usando \t\t\t, por exemplo.

João, deu para perceber que

todos esses códigos necessitam
da barra invertida... certo?

Exatamente, amigo leitor. Para o Python, a \ é um “caractere de escape”. A barra invertida é o símbolo que você
deve usar para que o próximo caractere seja interpretado de forma diferente pela linguagem, como nós acabamos
de ver com o \t, o \” e o \’. Vamos a mais uma combinação?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 86

A combinação \n (barra-invertida seguida da letra n) é usada para criar uma nova linha naquela posição. Seria
o equivalente ao digitar ENTER num texto num programa qualquer.

print("Continuando... \nEra uma vez... \nUm lobo barbudo...")

resulta em:

Continuando...

Era uma vez...

Um lobo barbudo...

Ei, João, e se eu quiser

apresentar ao usuário a
própria barra-invertida?

Aí você usará, caro leitor, a combinação \\ (duas barras-invertidas) exatamente no local onde deseja que a barra-
invertida apareça para o usuário.

print("Mostrando uma \\ [barra-invertida] para o usuário")

resulta em

Mostrando uma \ [barra-invertida] para o usuário

22.2. Aspas Triplas

Já havíamos sido apresentados rapidamente às aspas triplas, não é mesmo? O recurso de """ (aspas triplas) pode
ser usado para fazer comentários no meio do código, como já havíamos visto, mas também pode ser usado para
escrever um conteúdo no corpo do código exatamente como a gente quer que ele seja escrito para o usuário
(inclusive podendo usar códigos especiais como os que vimos acima).

Tudo aquilo que estiver dentro das aspas triplas será respeitado exatamente como estiver lá, incluindo as quebras
de linha que você usou (ENTER) no meio do código. Vamos ver isso?

texto = """

Quando você perceber que, para produzir, precisa obter a autorização de

quem não produz nada; quando comprovar que o dinheiro "flui" para quem

negocia não com bens, mas com favores; quando perceber que muitos ficam

ricos pelo suborno e por influência, mais que pelo trabalho, e que as leis

não nos protegem deles, mas, pelo contrário, são eles que estão protegidos

de você; quando perceber que a corrupção é 'recompensada', e a honestidade

se converte em auto-sacrifício; então poderá afirmar, sem temor de errar,

que sua "sociedade" está condenada. \t Ayn Rand"""

print("*" * 73)

print(texto)

print("*" * 73)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 87

O resultado deste programa é:

*************************************************************************

Quando você perceber que, para produzir, precisa obter a autorização de

quem não produz nada; quando comprovar que o dinheiro "flui" para quem

negocia não com bens, mas com favores; quando perceber que muitos ficam

ricos pelo suborno e por influência, mais que pelo trabalho, e que as leis

não nos protegem deles, mas, pelo contrário, são eles que estão protegidos

de você; quando perceber que a corrupção é 'recompensada', e a honestidade

se converte em auto-sacrifício; então poderá afirmar, sem temor de errar,

que sua "sociedade" está condenada. Ayn Rand

*************************************************************************

Perceba que na penúltima linha foi usado um \t. Este código especial foi respeitado e se converteu numa tabulação
(afastamento) na saída para o usuário, antes do nome da Ayn Rand. Perceba também que as aspas (duplas e
simples) nas palavras "flui", 'recompensada' e "sociedade" foram inseridas sem que fosse necessário usar
códigos especiais para sua inserção.

Nas aspas triplas, tais caracteres e as quebras de linha não precisam ser apresentadas com caracteres especiais
\n. Apenas a tabulação horizontal (\t) é que precisa ser oficialmente apresentada. Ahhh, também não custa
lembrar que tanto faz se você usa """ (aspas triplas) ou ''' (apóstrofos triplos), pois o resultado é o mesmo!

22.3. Vamos Exercitar a Lição?

Quais os resultados dos códigos abaixo?

a = " A civilização é o avanço de uma sociedade\nem direção à privacidade. O selvagem tem
uma vida pública,\nregida pelas leis de sua tribo.\n Civilização é o processo de
libertar\no homem dos outros homens.\n\tAyn Rand"

print(a)

a = """Só existem duas formas dos homens lidarem uns com os outros:

Armas ou lógica. \t\t Força ou persuasão.

Aqueles que sabem que não podem vencer por meio da lógica sempre recorrem às armas.\nAyn
Rand"""

print(a)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 88

23. Formatando Texto
23.1. Uma Nova Forma de Concatenar Textos e Variáveis
Vamos analisar o código a seguir:

nome = "João"

idade = 42

print(Nome + " tem " + str(idade) + " anos de idade.")

O resultado deste programa é a impressão, para o usuário da frase:

João tem 42 anos de idade.

Bom, isso foi um jeito simples, e já conhecido, de concatenar, numa única string, algumas variáveis e algumas
strings. O uso do sinal de + (adição) para concatenar já é conhecido, né?

Lembrou que precisamos colocar um espaço antes e/ou depois de cada trecho de texto entre aspas, né? Se não
fizermos isso, as palavras concatenadas ficarão todas juntas.

Perceba que, neste caso (usando o sinal de +), também foi necessário usar a função str( ) na variável idade,
porque ela é do tipo integer, conforme vemos lá em cima no momento em que nós atribuímos a ela o valor 42.

Lembre-se que não dá para concatenar uma string e um valor não-string com o sinal de +.

Peraí, João, mas podemos

escrever esse mesmo programa
de outra forma, não podemos?

Sim, amigo leitor! Podemos escrever o mesmo comando print() de outra maneira! Podemos separar cada item a
ser mostrado por uma vírgula. Neste caso, nem precisamos converter os valores inteiros (ou seja, não
precisaremos da função str( )) e nem precisaremos colocar os espaços antes e depois de cada trecho de string:

nome = "João"

idade = 42

print(nome, "tem", idade, "anos de idade.")

O resultado deste programa é o mesmo:

João tem 42 anos de idade.

Estas são facilidades da função print() – tratar números como strings e colocar automaticamente um espaço
entre os itens. Espertinha, não?

23.2. Textos Formatados – Concatenar Strings e Variáveis

Ainda nos resta conhecer uma outra forma de trabalhar "misturando" textos e variáveis: o texto formatado. O que
chamamos de f strings. O funcionamento é um pouco mais complicado que os exemplos anteriores, mas não é
nada impossível de entender!

[A] Primeiro: temos que colocar uma letra f antes da string que desejamos formatar. Ou seja, em vez de
escrever "casa", vamos escrever f"casa" (tem que ser encostado na string, mesmo, sem espaços entre f
e as aspas). É assim que o Python entende que a string vai ser formatada (esta é uma maneira recente).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 89

 [B] Segundo: no exato local onde as variáveis precisam ser incluídas no texto, nós colocamos o nome das
variáveis envolvidos por { e } (ou seja, chaves).

Pronto! Isso quer dizer que, no código:

nome = "João"

idade = 44

print("O professor", nome, "tem", idade, "anos de idade")

A última linha pode ser reescrita assim:

print(f"O professor {nome} tem {idade} anos de idade")

Preste atenção para colocar os símbolos certos entre as palavras e as variáveis, como os espaços e as
pontuações que são colocados antes das { e depois das }, ok? Em ambos os casos, o resultado será:

O professor João tem 44 anos de idade

Ei, mas se liga! Não precisa ser necessariamente apenas uma variável dentro das chaves! Pode ser uma
expressão qualquer que use variáveis (ou não), como um cálculo.

print(f"O professor {nome} tem {idade * 2} anos de idade")

Repare no trecho {idade * 2}. Ele vai apresentar o resultado da multiplicação do valor da variável idade por 2. O
resultado, portanto, deste código é:

O professor João tem 88 anos de idade

O método .format( ).

Além de usar a f string, podemos usar outro jeito de formatar strings: o método .format( ).

Lembra o que é um método, né? Um método é uma função que é usada como "sobrenome" de um objeto, sempre
escrito depois do objeto para o qual ele aponta.

Desta forma, em vez de usar f"casa", podemos usar "casa".format(). E nós colocaremos as variáveis e expressões
como argumentos (parâmetros) do método, ou seja, dentro dos seus parênteses. Ei! .format() tem que ser escrito
encostado nas aspas que fecham a string, ok? Sem espaços!

nome = "João"

idade = 44

mensagem = "O professor {} tem {} anos de idade".format(nome, idade)

print(mensagem)

Note que os indicadores {} são colocados onde desejamos que os dados sejam inseridos, mas não precisamos
colocar seus nomes dentro das chaves. Os nomes das variáveis foram informados dentro do
método .format(nome, idade).

Como há dois indicadores { } e temos dois argumentos dentro do método .format( ), cada um deles será substituído
por cada argumento do método, em ordem de ocorrência. Ou seja, o primeiro {} será substituído pelo valor da
variável nome e o segundo {} será substituído pelo valor existente na variável idade.

O resultado será, como sabemos, o mesmo das anteriores:

O professor João tem 44 anos de idade

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 90

Uma outra forma, melhorada, permite que você use combinações mais poderosas com esse recurso é que é
possível colocar "apelidos" para as chaves, fazendo com que possamos apontar para eles mais de uma vez. Veja
no exemplo:

num = 12

nome = "Mises"

mensagem = "{a}. Nosso autor número {a} é o {b}.".format(a=num, b=nome)

print(mensagem)

O resultado deste código é:

12. Nosso autor número 12 é o Mises.

Note que é necessário:

[A] Definir, dentro das chaves, algum apelido para o dado que será ali colocado;

[B] Dentro dos parênteses, escrever a expressão apelido=variável para associar o apelido usado na string
com alguma variável já existente. É necessário nomear cada apelido que será usado na string. Não
funcionará se você se esquecer de algum.

Perceba que neste caso do método .format( ), também não é necessário converter valores que são originalmente
números (como foi o caso da variável num).

23.3. Vamos exercitar?

Descreva qual a saída [na tela] do programa a seguir:

lista = ['Mises','Hayek','Menger','Hoppe', 'Friedman']

for index in range(1,4):

mensagem = "{num}. {nome}"

print(mensagem.format(num=index, nome=lista[index]))

print("Lista encerrada")

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 91

24. Muitos Programas para Estudar!
24.1. Descreva quais as saídas (na tela) para os Programas a seguir:
(Responda diretamente aqui – sem usar o Pyhton – use a sua mente para responder)

Programa 1 – Trabalhando com Listas

nomes = ['Mises','Hayek','Hoppe','Friedman']

for xy in nomes:

if xy != "Hayek":

print("O autor é {}.".format(xy))

else:

print("{} é um Gênio!")

print("Fim do Programa")

Programa 2 – Cálculos
a, b, c = 10, 20, 30

if c > 3 * b:

a += 10

b *= a

else:

a *= c

b += a

print(a, b)

24.2. Escreva um programa que…

Receba nomes e notas dos alunos e os insira em duas diferentes listas. Ao digitar "x", o
sistema para de capturar nomes e notas e já mostra a lista dos alunos no seguinte formato:
==============================

Nome Nota

==============================

Fulano 9.0

Beltrano 2.0

Trajano 5.0

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 92

Receba vários números diferentes até que se digite "x". Depois de encerrada a captura dos
números, o sistema irá apresentar na tela: [a] a lista contendo todos os números inseridos
pelo usuário apresentados em ordem crescente, [b] o maior número entre eles, [c] o menor
número entre eles, [d] a soma de todos os números inseridos e [e] a média aritmética de
todos eles.

Receba vários nomes e notas dos alunos [encerra a recepção dos dados quando digitar "x"].
Se a nota do aluno for menor que 7, que o nome dele e a sua nota sejam armazenados numa
determinada lista – a lista de alunos problemáticos. Se a nota do aluno for igual ou maior que
7, que seu nome e sua nota sejam inseridos em outra lista – a lista de bons alunos. Ao término
do programa, mostrar a seguinte tela:
==============================

Alunos Bons

==============================

Fulano 9.0

Beltrano 8.0

Trajano 7.5

==============================

Alunos Problemáticos

==============================

Mariano 3.0

Lugano 5.0

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 93

25. Construindo Nossas Próprias Funções
Uma função é um "pedaço de código", um "trecho" de código, um "fragmento" de código que pode ser usado mais
de uma vez! Nós construímos funções para não termos que repetir código desnecessariamente.

Podemos criar funções usando o comando def, que é uma contração para "definir". Ou seja, o ato de definir uma
função é o ato de criá-la, de dizer como ela vai funcionar, quais as formas de usá-la.

Pense numa função como uma ferramenta (um martelo ou um alicate, por exemplo). Se você não tem um martelo,
mas pode construí-lo, faça-o! A partir daquele momento, você vai usar sempre aquele martelo! Ele será muito
útil! Ou seja, você o constrói UMA VEZ, mas depois disso poderá usá-lo VÁRIAS VEZES!

Vamos construir nossa primeira função:

def rodape():

print("=" * 30)

print("Atenção! O programa terminou!")

print("=" * 30)

Pronto! Criamos uma função que será usada sempre no final de nossos programas, para colocar na tela o
seguinte:

==============================

Atenção! O programa terminou!

==============================

Uma vez criada a função, para usá-la, nós a chamamos (o termo que os vários autores de informática usam é
esse: "chamar uma função" – é o mesmo que "mencionar seu nome", ou "usar aquela função").

Basta, realmente, mencionar aquela função no exato local do código onde você quer que ela execute seus
comandos. Olha isso:

def rodape(): #Aqui, a função foi definida [ou seja, criada]

print("=" * 30)

print("Atenção! O programa terminou!")

print("=" * 30)

num = 80

print(num * 3)

rodape() #Aqui, a função foi chamada [ou seja, utilizada]

O resultado deste código pode ser visto na página seguinte:

240

==============================

Atenção! O programa terminou!

==============================

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 94

Não esqueça que a criação de uma função exige, também, que todos os comandos dentro daquela função sejam
indentados para que o Python entenda que eles fazem parte da função, como mostra o exemplo a seguir:

def funcao_exemplo():

este comando faz parte da função

este comando faz parte da função

este comando NÃO FAZ PARTE da função

25.1. Construindo Funções com Argumentos

Além de serem usadas para "repetir" trechos de código ao longo do programa, Funções podem ser usadas para
tratar algum valor que é informado a elas.

No caso mostrado anteriormente (da função rodape( ) que nós havíamos criado), a função simplesmente não
recebe informação alguma. Ela simplesmente é chamada e realiza os comandos que haviam sido colocados
dentro dela.

Podemos, porém, criar funções que recebam dados (os argumentos) e que, com isso, façam alguma coisa com
esses dados. Vamos ver o exemplo a seguir:

def dobro(num): #Aqui, a função é definida para receber um argumento

print("O dobro de", num, "é", num*2)

print("Testando a Função com argumentos")

dobro(15)

dobro(20)

dobro(80)

O resultado deste código é:

Testando a Função com argumentos

O dobro de 15 é 30

O dobro de 20 é 40

O dobro de 80 é 160

Note que a cada vez que a função dobro( ) foi chamada, nós colocamos um número diferente dentro dos
parênteses (mudamos o argumento). A cada novo argumento passado para a função, ela realizou seu comando
"print" com um dado diferente, imprimindo uma informação diferente.

Então, vamos a um "vocabulário" para definir alguns conceitos sobre funções:

Definir uma Função ou "Declarar" uma função: significa dizer ao Python que aquela função existe, ou seja, é
definir uma função é construí-la.

Chamar uma Função: é a mesma coisa que usá-la. Chamar uma função é mencionar o seu nome no meio do
programa. É assim que nós usamos as funções.

Passar um Argumento para uma Função: é a mesma coisa que informar um dado para que a função trabalhe
corretamente. Passar um argumento (ou parâmetro) é justamente colocar um dado dentro dos parênteses de
uma função, na hora de chamá-la, para ela trabalhar com ele.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 95

Funções que recebem vários argumentos

Uma função pode receber mais de um argumento, desde que você a declare assim. Vejamos o exemplo abaixo:

def maior(a,b):

if a > b:

print(a, "é maior que", b)

elif b > a:

print(b, "é maior que", a)

else:

print("os números são iguais")

print("Testando Função com dois argumentos")

maior(10,30)

maior(80,30)

maior(30,30)

O resultado do programa acima é o seguinte:

Testando Função com dois argumentos

30 é maior que 10

80 é maior que 30

os números são iguais

Funções com Números Incertos de Argumentos

Existem funções que não se importam com a quantidade de argumentos que passamos para elas. Veja o exemplo
das funções max( ) e min( ).

a = max(1, 10, 2, 3, 4, 8, 12, 6)

b = max(2, 30, 4)

Os dois usos da funçao max( ) acima receberam quantidades de parâmetros diferentes: ao usar no primeiro
exemplo, colocamos 8 argumentos; no segundo uso, passamos apenas 3 parâmetros.

A maneira de criar uma função que aceite inúmeros parâmetros (sem que saibamos exatamente quantos) é
colocando um sinal de asterisco no nome do argumento quando declaramos a função.

def muitos(*dados):

print("A soma dos dados é:", sum(dados))

print("O maior número é:", max(dados))

muitos(3, 4, 5, 6, 7, 8) # usando a função com 6 argumentos

muitos(2, 3) # usando a função com 2 argumentos

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 96

O resultado do código acima, em que a função muitos( ) foi usada duas vezes, é:

A soma dos dados é: 33 # Resposta do primeiro uso da função muitos()

O maior número é: 8

A soma dos dados é: 5 # Resposta do segundo uso da função muitos()

O maior número é: 3

Quando usamos * no argumento da função em sua definição, estamos indicando que os argumentos formarão
uma tupla.

25.2. Vamos Exercitar esta Lição?

Construa uma função que receba dois valores e que apresente na tela a soma deles. Depois,
chame-a com os valores 30 e 50.

Construa uma função que receba três valores e que imprima na tela uma mensagem
informando se há valores repetidos entre eles. Chame a função passando os valores 30, 20 e
30 e depois chame-a com os valores 10, 30 e 80.

Construa uma função que receba três palavras e as imprima na tela em sequência alfabética,
com um espaço entre elas.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 97

26. As Variáveis Dentro das Funções
26.1. Analisando o "Escopo" de uma Variável
Em programação, é muito importante entender o "escopo" das variáveis. Uma variável tem uma "área de atuação",
uma "região" onde ela atua... isso é o escopo dela. Por exemplo, uma variável que foi definida dentro de uma
função só funcionará dentro daquela função, mesmo que haja outra variável com o mesmo nome sendo usada
fora da função.

def calculo(a, b, c):

print(a + b * c)

calculo(2,3,4)

teste = a + 10 #Aqui vai dar erro porque não há variável a conhecida

No programa acima, as variáveis a, b e c foram definidas dentro da função calculo( ). Elas não podem ser usadas
fora dela. A linha teste = a + 10 vai apresentar um erro porque a variável a nunca foi declarada fora da função.

Outra coisa é que as variáveis declaradas fora da função não influenciam as variáveis declaradas dentro da
função, mesmo que tenham o mesmo nome – para o Python, são variáveis diferentes.

a = 10 #Essas variáveis não influenciam as variáveis na função

b = 4

def calculo(a, b, c): # Essas variáveis a, b e c só existem aqui

print(a + b * c) # dentro dessa função

calculo(b,b,b) # Aqui, estamos chamando a função e passando os

calculo(a,a,a) # parâmetros [argumentos] que queremos para ela

calculo(a,b,10)

O resultado do programa acima vai ser a impressão de três linhas na tela, contendo os valores:

20

110

50

26.2. O Valor Padrão de uma Variável

Se uma função foi construída para receber 3 argumentos, o usuário deverá chamá-la no programa informando
esses 3 argumentos (essa é a regra geral). Se você constrói uma função qualquer com:

def funcao_qualquer(arg1, arg2, arg3):

Mas na hora de chamar a função, você faz a besteira de chamá-la assim:

funcao_qualquer(100, 200)

(note que ela foi chamada informando apenas dois argumentos) – Isso vai dar um erro! O Python irá mostrar uma
mensagem de erro (que é mostrada no inicio da próxima página).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 98

 File "/Users/joao/Documents/prova.py", line 8, in <module>

funcao_qualquer(100,200)

TypeError: funcao_qualquer () missing 1 required argument: 'arg3'

A última linha da mensagem diz "missing 1 required argument" (1 argumento necessário está faltando), e
aponta que é o arg3 que está em falta.

Para evitar isso, e, claro, para tornar um dos argumentos desnecessário, podemos criar um "valor padrão" para
o argumento, caso ele não seja informado.

É muito fácil fazer isso: basta colocar argumento=valor na própria definição da função. Veja:

def maior(a,b=10): #Aqui, definimos que 10 é o valor-padrão de b

if a > b:

print(a, "é maior que", b)

elif b > a:

print(b, "é maior que", a)

else:

print("os números são iguais")

print("Testando Função com dois argumentos")

maior(10,30) #Aqui o 30 é passado como argumento b

maior(80) #Aqui o 10 [valor-padrão] será considerado como b

maior(6) #Aqui também o valor-padrão será considerado como b

O programa vai apresentar na tela isso aqui:

Testando Função com dois argumentos

30 é maior que 10

80 é maior que 10

10 é maior que 6

Perceba que nos casos em que não informamos o segundo argumento, o Python considerou que o argumento b
da sua função tem valor 10. Isso evita o erro e permite que você crie um valor básico, comum, para o argumento.
Você vai perceber a necessidade disso em algum momento enquanto estiver programando!

Todos os argumentos de uma função podem ter valor-padrão, veja:

def soma(num1=30,num2=20):

print("A soma dos dois é:", num1 + num2)

soma(10,400)

soma(80)

soma()

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 99

O resultado deste código é:

A soma dos dois é: 410

A soma dos dois é: 100

A soma dos dois é: 50

Note que no primeiro exemplo, foram passados os dois argumentos na função. Ela resultou, portanto, em 410 (a
soma do 10 com o 400). No segundo exemplo, só foi passado o argumento 80, o Python considerou o segundo
argumento com seu valor-padrão (que é 20), portanto, o resultado deu 100.

No terceiro exemplo, nenhum argumento foi passado para a função – ela teve de considerar os dois valores-
padrão: 30 e 20. Por isso o resultado deu 50.

26.3. Vamos Exercitar?

Qual a saída do programa a seguir?

(não use o Python... analise o programa aqui mesmo e – com sua mente – imagine qual é a saída do programa)

num = 30

def calculo(num, pot=2):

if num <=100:

print("{} elevado a {} é igual a {}".format(num, pot, num**pot))

else:

print("Não é possível fazer cálculos maiores que", 100**2)

calculo(20)

calculo(2,5)

calculo(120,130)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 100

27. Funções Retornando Valores
27.1. Funções podem Trazer Resultados
Até agora, usamos funções apenas para "mostrar" valores (colocamos um comando print() dentro delas para que
elas possam apresentar valores na tela). Acontece que uma função pode ser escrita para não mostrar valores,
mas para retorná-los (devolver resultados) e nós vamos ver isso agora.

Acompanhe o programa simples a seguir:

def mostra_dobro(num):

print(num*2)

mostra_dobro(10)

A função mostra_dobro( ) exige um argumento como valor e vai mostrar o valor na tela (graças à função print()
lá dentro). Por causa disso, a função pode ser usada diretamente como na linha mostra_dobro(10). O resultado
do programa acima é:

20

O número 20 foi impresso na tela porque a função print(num*2) está dentro da função mostra_dobro(num) – e
nós chamamos esta função passando para ela o valor 10.

Vamos aprender uma nova forma de utilização das funções? Olha o programa abaixo:

def calcula_dobro(num):

return num * 2

Note que a função calcula_dobro( ) não manda, em seu interior, nenhuma informação ser impressa na tela (não
existe a função print() ali dentro). O comando return indica que a função deve oferecer como resultado (ou seja,
como resposta da função) justamente o num * 2.

Mostrar na tela é uma coisa (você já sabe que se consegue isso com a função print()). Retornar um valor é outra
coisa bem diferente (não aparece nada na tela com o comando return).

Quando uma função retorna um valor, a gente tem que fazer algo com esse valor: que pode ser armazená-lo
numa variável ou mesmo imprimi-lo diretamente por meio de uma função print() no corpo do programa.

Veja isso na próxima página:

def calcula_dobro(num): # Esta é a função sendo declarada (construída)

return num * 2

numero = calcula_dobro(10) # Aqui, estamos usando a função

print(numero)

No programa acima, a variável numero receberá o resultado da função calcula_dobro( ) aplicada ao valor 10.
Depois, é só mandar imprimir o valor da variável numero.

O resultado é esse:

20

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 101

Os Segredos do Comando return

Dentro do código de uma função, o comando que indica qual será o valor-resultado desta função é o return. Nada
colocado após o comando return no corpo da função será entendido. Tudo depois do return será ignorado.

def ignora(numero):

return numero * 10 #A função para de executar aqui

print("pronto")

numero += 20

print("numero")

ignora(5)

print("Programa Terminado")

O programa acima resultará, apenas, em:

Programa Terminado

Note que nenhum dos comandos print() dentro do corpo da função ignora( ) foi executado. Isso porque o código
da função só é executado até o comando return.

Tudo aquilo que vier depois do comando return é, simplesmente, ignorado.

O comando return pode ser escrito da maneira como vimos acima:

return a + b

ou como se fosse uma função (com parênteses):

return(a + b)

O Python entende as duas formas.

27.2. Função Retornando Mais de Um Valor

Uma Função pode retornar mais de um valor – e esses valores podem ser atribuídos a mais de uma variável ao
mesmo tempo... Veja o exemplo:

def dobro_triplo(ancora):

return ancora*2, ancora*3

num1, num2 = dobro_triplo(10)

print(num1, num2)

O resultado deste programa é:

20 30

Note que a função dobro_triplo( ) foi construída para retornar dois valores: ancora*2 e ancora*3 (ancora é o
nome da variável interna que recebe o valor passado como argumento da função). O fato de a função "devolver"
dois valores ao mesmo tempo permite que usemos isso para preencher duas variáveis diferentes ao mesmo
tempo, o que fizemos na atribuição das variáveis num1 e num2.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 102

Você pode colocar os vários retornos de uma função numa única variável. Basta atribuir a função a uma variável
apenas.

def dobro_triplo(ancora):

return ancora*2, ancora*3

numero = dobro_triplo(10)

print(numero)

A variável numero vai se transformar numa tupla contendo os dois valores o resultado é este:

(20, 30)

Todas as vezes que atribuímos

mais de um valor a uma única
variável, ela vira uma tupla, né?

Exatamente, amigo leitor! A gente viu isso lá na lição sobre tuplas! Tem um lembrete bem chamativo na primeira
página da lição, logo antes da sua pergunta sobre “para que a tupla serve se ela é imutável?”.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 103

27.3. Que Tal Exercitar a Lição?

Quais as saídas apresentadas pelos programas a seguir?

def media(num1, num2):

return (num1 + num2) / 2

media(10,20)

media(30,10)

print("Fim do Programa")

def maior(num1, num2):

if num1 > num2:

return(num1)

else:

return(num2)

a = 20

b = 30

grande = maior(a,b)

print("O maior número entre", a, "e", b, "é", grande)

def teste(a, b, c=5):

return a + c * b

hoje = teste(10,20,2)

ontem = teste(20,10)

print(hoje + ontem)

print(teste(30,5,5))

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 104

28. List Comprehensions
28.1. O que são as List Comprehensions?
O Python tem uma forma muito fácil de criar listas seguindo as normas de uma expressão lógica. List
Comprehensions seriam, justamente, essas expressões lógicas.

Podemos definir assim: List Comprehensions são expressões lógicas que servem como regras na criação de
listas, determinando quais elementos vão fazer parte da lista e quais não irão.

Não usamos o termo "List Comprehension" de forma traduzida para o português porque fica realmente bem
estranho... seria "Compreensões da Lista" – ou talvez seria bom traduzir como "Lista Compreensível" (que meigo,
não?).

Vamos entender como funciona? Primeiro, vamos imaginar que queremos criar uma lista com todos os quadrados
dos números de 1 a 10. A lista desejada ficará exatamente assim:

lista = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100].

Note que 1 é 12, 4 é 22, 9 é 32, 16 é 42 e assim por diante. A lista obedece aos critérios exigidos mencionados
anteriormente, mas foi construída manualmente, ou seja, o programador teve de digitar cada item um a um. Um
trabalho manual e muito chato (imagina se fossem 100 itens...).

Dá para construí-la de forma automática? Sem recorrer a fazer todos os itens manualmente? Sim! Dá uma olhada
na expressão abaixo:

lista = [x**2 for x in range(1,11)]

Traduza essa expressão como: crie uma lista com item de valor x2 para cada x dentro da sequência que tem
range(1,11). (lembre-se que a range( ) não inclui o item final, ou seja, o 11).

O Python, portanto, vai iterar x dentro da range(1,11) (isso significa que x vai variar de 1 a 10) e a cada iteração,
vai elevar o valor de x ao quadrado (é o que significa o x**2, lembra?) e inserir esse valor na nova lista.

Vamos experimentar outro exemplo?

lista = [num+5 for num in range(10,200,13)]

Esta expressão significa: para cada item num na sequência que vai de 10 a 200, iterando de 13 em 13, crie um
item de valor num + 5. O resultado deste comando é uma lista com os seguintes itens:

[15, 28, 41, 54, 67, 80, 93, 106, 119, 132, 145, 158, 171, 184, 197]

Usando if na Expressão para ser mais seletivo

As List Comprehensions podem ganhar uma ajuda incrível da cláusula if. Sim! Podemos ser bem mais seletivos
e escolher alguns itens apenas da listagem a ser criada (ou seja, não aceitar todos eles, ou definir mais uma
exigência para a inclusão dos itens na nova lista).

Que tal se a regra fosse: adicione todos os números de 1 a 30 apenas se eles forem múltiplos de 4.

Ôxi, João, e como vamos

saber se um bendito
número é múltiplo de 4?

Ora, é simples: quando o resto da divisão dele por 4 der 0! Ou seja, quando a divisão dele por 4 é exata.

Incluímos, portanto, a cláusula if na nossa Comprehension:

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 105

 lista_nova = [x for x in range(1,30) if x % 4 == 0]

Podemos traduzir como "crie um item x, que esteja dentro da range(1,30) apenas se o resto da divisão desse x
por 4 for igual a 0 [zero]".

O Python irá iterar (varrer a sequência) de 1 a 29 (o 30 não é incluído, lembra?) e testará se cada número daquela
iteração é divisível por 4. Se for, o número x daquela iteração é incluído na lista_nova; se o número x daquela
iteração não for divisível por 4, o número não será incluído na lista_nova.

O resultado deste comando é a lista_nova ser construída com esses itens:

[4, 8, 12, 16, 20, 24, 28]

List Comprehensions com Texto

Não fique achando que a gente só consegue usar expressões lógicas para criar listas com números, não! O
bagulho é sinistro! Dá para fazer muita coisa além disso – inclusive com texto!

Vamos ver um exemplo! Imagine a seguinte lista:

alunos = ["João", "Ana", "Alberto", "Pedro", "Antonio", "Mateus", "Davi", "Miguel",

"Alice", "Bernardo", "Heitor", "Ângela"]

E é nosso desejo criar uma segunda lista contendo apenas os nomes dos alunos que começam com a letra "A".
Como fazer? Com uma expressão:

lista_a = [nome for nome in alunos if nome[0] == "A"]

A expressão acima pode ser traduzida como: crie a lista_a contendo nome, analisado da lista alunos, nome por
nome, somente se a posição 0 da string nome na lista alunos seja igual a "A".

Ô João, e por que

daquela cláusula
nome[0] == "A"?

Porque, como vimos anteriormente, uma string pode ser acessada como uma lista.

Cada letra de uma string pode ser acessada separadamente, como se fosse uma "posição" na string. A primeira
letra de uma string sempre é a posição 0 [zero] dessa string. (a segunda letra é a posição [1], a terceira letra é a
posição [2], a quarta letra da string é a posição [3] e assim por diante).

O resultado desta expressão criará a lista_a com o seguinte conteúdo:

['Ana', 'Alberto', 'Antonio', 'Alice']

Ei, João, por que a Ângela

não foi incluída na lista_a?
É por causa do circunflexo?

Precisamente, amigo leitor! Ao definir a condição nome[0]==”A”, a Ângela não pode ser incluída porque seu nome
não começa com “A”, mas sim com “”, que é um caractere diferente!

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 106

28.2. Vamos Exercitar List Comprehensions?

Descreva a lista que será criada ao escrever cada uma dessas expressões:
lista = [w*3 for w in range(3,20,3)]

lista = [k-1 for k in range(5,10) if k != 7]

lista = [num//3 for num in [10, 15, 19, 22, 23]]

lista = [x+4 for x in range(1,6) if x*2 > 5]

Analise o código abaixo. Qual a saída na tela?

(não vá testar no Python! Responda aqui e agora!)

lista = ['a', 'b', 'c', 'd', 'e', 'f']

nova_lista = [letra * 3 for letra in lista if letra != 'c']

nova_lista.pop()

nova_lista.reverse()

for i in nova_lista:

print(i*2)

print("Fim do Programa")

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 107

29. Mais Segredos com while
29.1. Voltando ao Loop Infinito
Quando fomos apresentados aos dois laços de repetição da linguagem Python, o for (que usamos quando sabemos
quantas vezes o laço deverá ser realizado) e o while (que usamos quando não sabemos), vimos que no segundo
caso (no while), existe a possibilidade de loop infinito.

Um loop infinito acontece quando uma condição inicialmente verdadeira é testada no while e, dentro dele,
nenhuma alteração nesta condição é feita. Ou seja, o while irá sempre repetir as mesmas coisas, o tempo todo...
Um código de exemplo pode ser visto a seguir:

senha = 10

while senha > 3:

print("repetido") # Esta linha será repetida para sempre

Para evitar que essa linha se repita para sempre, poderíamos adicionar uma linha que diminuísse o valor da
variável senha em 1 a cada loop, o que faria com que ela, em algum momento, a variável senha fique com valor
3, o que tornaria a condição do while falsa, fazendo o loop parar. A solução seria essa:

senha = 10

while senha > 3:

print("repetido")

senha -= 1 # Esta linha diminui o valor de senha em 1. Garantia de que

# o loop vai parar algum dia.

Porém, em alguns casos, é necessário que o loop seja, realmente, "infinito" – porque não sabemos quantas vezes
o loop será realizado (depende do usuário do nosso programa). Um caso muito comum é um "menu principal" em
um programa. Um menu que apresente várias opções ao usuário e que deva ser sempre mostrado, várias e várias
vezes, porque o usuário o utilizará diversas vezes seguidas.

Neste caso, deve haver uma forma de dizer ao programa que o usuário não quer mais que aquele menu apareça
para ele e, com isso, o programa termine. Isso é muito fácil: basta que o usuário digite que quer sair! Ou seja,
basta que a condição do while seja alterada por meio de algo que o usuário digite.

Vamos ver esse exemplo? Vamos começar criando uma variável chamada opcao e dar a ela o valor 1, depois
fazer o while fazer loop enquanto a variável opcao for diferente de 0 (zero). O começo do nosso código é esse
aqui:

opcao = 1

while opcao != 0:

# Comandos dentro do Loop while

Isso constitui um loop infinito, percebeu? A variável opcao é 1 e a condição do while é verdadeira, caso a variável
opcao não seja alterada, os comandos dentro do while vão se repetir infinitamente.

Mas, João... esse

programa é só isso?
Não tem mais nada?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 108

Não, amigo leitor! Vamos agora colocar o programa mais completo, com opções de escolha para o usuário:

opcao = 1 # O Programa começa aqui, definindo opcao como 1 para o loop executar.

while opcao != 0:

print("=" * 30)

print("Cadastro de Alunos")

print("=" * 30)

print("") # Aqui, coloquei uma linha vazia depois do cabeçalho.

print("Incluir Aluno [1]")

print("Alterar Aluno [2]")

print("Excluir Aluno [3]")

print("Sair [0]")

opcao = int(input("Digite a Operação Desejada: ")) # Aqui, o usuário digita o

# número da opcao

# Aqui, o programa continua com as operações que você quiser...

# Quando o programa terminar, e tentar fazer outro loop desses, se a opcao estiver
com 0, ele para!

Perceba que o programa começou com a atribuição do valor 1 para a variável opcao. Depois, imediatamente, o
laço while começou testando se a variável opcao era diferente de 0 (zero) – e ela é, por isso o laço será realizado.

O programa rodando exibe algo como isso aqui:

==============================

Cadastro de Alunos

==============================

Incluir Aluno [1]

Alterar Aluno [2]

Excluir Aluno [3]

Sair [0]

Digite a Operação Desejada:

Nesta última linha, o usuário deverá digitar um valor que, segundo o programa, será armazenado na variável
opcao, depois de convertido para inteiro (note lá no código o int(input...)).

Na parte inferior do código, após o menu principal, coloquei apenas dois comentários, mas o lógico a fazer é tratar
o que o usuário digitou e fazer o programa rodar a operação que o usuário quer executar (Incluir, Alterar ou
Excluir alunos, ou, por fim, sair do programa).

Vamos fazer o programa certo?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 109

 opcao = 1

while opcao != 0:

print("=" * 30)

print("Cadastro de Alunos")

print("=" * 30)

print("Incluir Aluno [1]")

print("Alterar Aluno [2]")

print("Excluir Aluno [3]")

print("Sair [0]")

opcao = int(input("Digite a Operação Desejada: "))

if opcao == 1:

#Faça os comandos para Incluir Aluno

elif opcao == 2:

#Escreva aqui os comandos para Alterar o cadastro do aluno

elif opcao == 3:

# Escreva aqui os comandos para Excluir um aluno.

elif opcao == 0:

break # Preste atenção a esta linha!

else:

continue # E nesta aqui!

# Fim do Programa (já estamos fora do loop while)

Note que dependendo o valor da variável opcao, o programa fará coisas diferentes (o if, seguido de vários elif e
de um else fazem isso)... Neste "catatau" de coisa, eu só queria mostrar especificamente dois comandos: o
comando break e o comando continue.

O comando break, no código acima, está associado à cláusula elif opcao==0, ou seja, se o usuário digitar 0, o
comando que será executado é justamente esse break. E a função dele é bem simples: ele encerra o loop. Ele faz
o Python sair do loop. Quando o Python lê o comando break, ele sai do while e começa executando o primeiro
comando fora do loop.

Em suma, este comando é o que se usa para sair de um loop (seja ele infinito ou não).

Note bem: assim que o Python lê o comando break, ele salta para fora do loop. Ele deixa de executar os comandos
posteriores dentro do loop. Simplesmente ignora eles.

O comando continue tem uma "missão" diferente. Quando o Python lê este comando, ele salta para o início do
loop, ou seja, ele ignora tudo o que vem depois e volta ao início do loop para reiniciar todos os comandos do loop.
No caso de um loop for, ele itera o for, ou seja, ele salta para o início do loop e conta o próximo valor do for.

São dois comandos que ajudam muito no fluxo de um programa, essencialmente no while e no for.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 110

29.2. Vamos Exercitar?

Qual a saída para o código a seguir?

# print("Programa de Exemplo")

print("=" * 30)

senha = 'x'

while senha != 'z' :

if senha == 'a' :

print("primeira passagem")

break

senha = "b"

elif senha == 'x' :

print("segunda passagem")

senha = 'c'

continue

senha = 'x'

elif senha == 'c' :

print("terceira passagem")

senha = 'a'

#continue

else:

print("última passagem")

break

print("-" * 30)

print("-" * 30)

print("fim do programa")

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 111

30. Tratamento de Erros no Python
Sabia que o seu programa pode apresentar inúmeros erros, né? Erros são causados por falhas de programação,
ou seja, na maioria das vezes é você o causador desses erros, amigo programador, amiga programadora!

Imagine o código a seguir:

print(a + 10)

Notou alguma coisa estranha? O código está mandando printar a variável a somada ao número 10. Mas a variável
a não existe! Não foi declarada antes! A resposta do Python será:

Traceback (most recent call last):

File "<pyshell#1>", line 1, in <module>

print(a+10)

NameError: name 'a' is not defined

Veja a última linha deste erro: name 'a' is not defined (a variável a não foi definida antes). Corrija seu código e
tente novamente!

Ei, João, mas os usuários

também podem causar
alguns problemas, né?

Ô! E como!! Usuários podem ser causa de muitas agonias em nossas vidas, pode ter certeza, meu amigo! Para
este caso, podemos "prever" alguns comportamentos e usar um recurso bem interessante.

Veja o código a seguir que pede o nome e a idade de um usuário.

nome = input("Digite o seu nome:")

idade = int(input("Digite a sua idade:"))

Um código simples, né? Ele vai guardar o resultado do primeiro input na variável nome e vai converter para
inteiro o resultado do segundo input, guardando-o na variável idade. Até aí, nenhuma dificuldade, né?

Mas não podemos "subestimar" as capacidades destruidoras do usuário, meu amigo leitor! Imagine que o usuário
invente de digitar "dezoito anos" quando lhe for pedida a idade... (em vez de digitar "18").

Ora, como aquela linha de código vai converter o input para inteiro (graças à função int( ) aplicada ali ao input),
ela não poderá receber "dezoito", mas consegue receber "18". Afinal, todo input é, necessariamente, um string.

Veja aquele programa rodando com o caso acima descrito:

Digite o seu nome: João Carlos

Digite a sua idade: dezoito anos

Traceback (most recent call last):

File "<pyshell#3>", line 1, in <module>

idade = int(input("Digite a sua idade:"))

ValueError: invalid literal for int() with base 10: 'dezoito anos'

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 112

Se esta mensagem aparecer para o usuário, ele vai surtar (como se ele já não fosse surtado o suficiente, né?).

Temos que prever a burr... ops, o erro do usuário. É nossa obrigação, enquanto programadores, prever quais
erros o usuário poderá cometer e já tentar tratar esses erros para que o programa não trave nem dê mensagens
de erro estranhas...

30.1. O laço try

Uma das formas de "prever" erros no Python é usar o laço try ("tentar" em inglês). Ele é usado da seguinte
maneira:

try:

comando que pode dar erro (será testado)

except:

o que fazer caso dê erro

Então, poderíamos imaginar que o usuário vai causar o erro mostrado lá em cima, digitando "dezoito" em vez de
"18", a gente escreveria:

try:

idade = int(input("Digite a idade:"))

except:

print("Ocorreu um erro. Você não digitou a idade!")

O que estiver debaixo do try: será testado. Se ele não der erro, o código é usado normalmente e nada de mensagem
de erro aparecerá. Se, porém, a execução do código der um problema, será executado o código que estiver abaixo
de except:.

Gostei, João! Tem mais alguma coisa

que podemos usar para nos proteger
contra as burr... ops, erros, do usuário?

Temos, sim, amigo leitor! Há “opções” além do try e do except. É preciso explicar que os blocos try: e except: são
obrigatórios nesta estrutura (devem ser escritos exatamente desta forma). Mas há outros dois opcionais que
podem ser somados a estes.

É possível usar os blocos else: e finally: após o try: e o except:. Funciona assim:

try:

comando que será testado

except:

o que fazer caso dê algum problema (caso o comando dê algum erro)

else:

o que fazer caso o comando funcione sem erro

finally:

o que fazer caso dê ou não dê erro (vai fazer obrigatoriamente)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 113

Um exemplo seria esse:

try:

a = int(input("Digite a sua idade:"))

except:

print("Aconteceu algum problema! Você fez besteira!")

else:

print("Ótimo! A sua idade é", a)

finally:

print("Programa finalizado!")

Qualquer um dos blocos acima pode ter mais de um comando dentro de si. Então, se você fizer um try: com mais
de um comando, ele analisará todos eles e só considerará que deve ir pro else: se todos estiverem corretos (ou
seja, se nenhum deles der erro).

Se apenas um deles apresentar um erro, o sistema automaticamente cairá no bloco except: executando tudo o
que estiver lá!

try:

a = int(input("Digite o primeiro valor:"))

b = float(input("Digite o segundo valor:"))

c = int(input("Digite o terceiro valor:"))

except:

print("Ops! Aconteceu algum erro aí!")

else:

print("Todos os dados foram recebidos!")

print("A soma deles é", a + b + c)

30.2. Vamos exercitar?

Qual a saída na tela para os programas a seguir?

lista = [1, 2, 3]

tupla = 1, 2, 3

try:

tupla[0] = lista[1]

print(lista, tupla)

except:

print("Não foi possível realizar a operação")

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 114

 A = 10

B = 20

X = 12

try:

c = a + b

d = c + a

except:

print(X)

else:

print(a)

print(b)

finally:

print("Fim")

lista = [1, 2, 3]

tupla = 1, 2, 3

try:

lista[0] = tupla[1]

except:

print("Não foi possível realizar a operação")

else:

print(lista)

print(tupla)

print("Fim")

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 115

31. Usando Módulos no Python
31.1. O que São Módulos?
Módulos são arquivos .py (arquivos normais de texto contendo código em linguagem Python) usados para
armazenar funções, classes e variáveis em ambiente separado dos arquivos do código do programa.

Usamos módulos para não precisar escrever sempre códigos muitos grandes e complexos.

Veja dois arquivos: um deles chamado funcoes.py (na

janela atrás) e outro com nome meu_codigo.py na
janela à frente.

Perceba que as funções foram definidas dentro do

código do funcoes.py, mas elas foram usadas no
código do meu_codigo.py.

Isso foi possível por meio da linha from funcoes import *.

O jeito mais simples de importar funções, classes e variáveis descritos em um outro arquivo é usando a função
import arquivo – neste caso, todas as funções, variáveis e demais códigos reutilizáveis poderão ser usados.

Porém, importar deste jeito exige que apontemos para as funções e variáveis com o prefixo arquivo.funcao( ) em
vez de apenas funcao( ). Veja a seguir:

import funcoes

a = 10

print(funcoes.dobro(a))

print(funcoes.triplo(a))

Atenção, a linha import arquivo usa o nome do arquivo sem a extensão .py. Os dois arquivos devem estar salvos
na mesma pasta para que isso funcione.

Você poderá importar um arquivo inteiro dando-lhe um apelido mais "curto" (mais fácil de digitar), com isso
evitaria ter de digitar "arquivo.objeto( )" todas as vezes que precisasse usar uma das funções ou variáveis que
foram importadas.

Para isso, basta usar import arquivo as apelido.

import funcoes as m # Importe funcoes com o apelido m

a = 10

print(m.dobro(a)) # Agora é só usar m em vez de funcoes

print(m.triplo(a))

Vai dar um "up" na velocidade de digitação, né?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 116

31.2. Importando apenas Componentes Específicos
É possível importar apenas componentes específicos de um arquivo, ou seja, sem importar o arquivo inteiro. Para
isso, usa-se a linha de comando from arquivo import componente (componente é uma função, ou uma variável,
ou uma classe)...

Quando você importa o componente em si, usando from arquivo, não é necessário se referir a ele com o prefixo
arquivo. ou m.! Veja no código abaixo:

from funcoes import dobro # Importe dobro do arquivo funcoes

a = 10

print(dobro(a)) # Agora dá pra usar dobro() sem prefixo

print(triplo(a)) # Essa vai dar erro porque não foi importada

Para importar todas as funções e variáveis de um arquivo, você pode usar a linha from arquivo import * (o
asterisco aqui significa "tudo").

from funcoes import * # Importe TUDO do arquivo funcoes

a = 10

print(dobro(a)) # Agora dá pra usar dobro() sem prefixo

print(triplo(a)) # Agora dá pra usar triplo() sem prefixo

31.3. Vamos Exercitar Módulos?

Analise este código, que foi salvo no arquivo origem.py:

def dobro(num):

return num * 2

def triplo(num):

return num * 3

def quadrado(num):

return num ** 2

def cubo(num):

return num ** 3

valor_padrao = 100

outro_valor = 200

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 117

Estes códigos apresentam algum erro?
import origem

a = 10

print(origem.dobro(a))

print(origem.metade(a))

from origem import *

a = valor_padrao * 10

print(origem.dobro(a))

print(origem.metade(a))

from origem import quadrado, cubo

a = outro_valor * 6

print(quadrado(a))

print(cubo(a))

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 118

32. Operadores Booleanos and e or
32.1. O que são Operadores Booleanos?
Operadores, como nós já vimos, são sinais que realizam operações (“fazem cálculos”). Nós já conhecemos vários
operadores aritméticos (sinais que fazem cálculos com valores numéricos), como +, -, *, /, **, //, e %.

Chegou a hora de conhecermos dois operadores booleanos, que são sinais que realizam operações com valores
booleanos (valores True ou False): o operador and e o operador or.

Assim como os operadores aritméticos devem ser posicionados entre dois valores numéricos (números ou
variáveis que contenham números), os operadores booleanos devem ser posicionados entre dois valores
booleanos (True ou False) ou entre duas proposições (expressões que podem ser True ou False).

situacao_mateus = True

situacao_lucas = b < 30

situacao_pedro = True or 40 > 20

No exemplo acima, declaramos 3 variáveis:

[A] A variável situacao_mateus foi declarada com o valor True (ela é booleana);

[B] A variável situacao_lucas foi declarada com uma proposição (b < 30): portanto, pode ser True ou False (é
booleana, também);

[C] A variável situacao_pedro foi declarada como o resultado de uma operação or entre o valor booleano
True e a proposição 40 > 20. (ela também é booleada).

Os resultados das operações or e and também são valores booleanos.

32.2. O Operador and

Usamos o operador and entre duas proposições (entre duas expressões booleanas) para que o resultado seja
True apenas se todas as expressões originais forem True.

Proposição 1 Proposição 2 Proposição 1 and Proposição2

True True True

True False False

False True False

False False False

Veja o código a seguir:

a, b = 10, 20 # Duas variáveis declaradas

if a<30 and b>5: # Testando as duas condições ao mesmo tempo (as 2 True)

print(a+b)

A função print() acima será normalmente executada porque as duas proposições (a<30 e b>5) são verdadeiras
(True), fazendo a operação and também ser True.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 119

O programa será executado e dará o seguinte resultado:

30

Observe, agora, este código:

a, b = 10, 20 # Duas variáveis declaradas

if a>20 and b>5: # Testando as duas condições ao mesmo tempo (1 delas False)

print(a+b)

A função print() acima não será executada porque das duas proposições (a>20 e b>5) apresentadas no laço if,
uma delas é False (falsa) – a proposição a>20 -, fazendo a operação and também ser False. E se a condição da
estrutura if for falsa, o if não será executado (o else seria).

32.3. O Operador or
Usamos o operador or entre duas proposições (entre duas expressões booleanas) para que o resultado seja True
se, pelo menos, uma das expressões originais for True.

Proposição 1 Proposição 2 Proposição 1 or Proposição2

True True True

True False True

False True True

False False False

Analise este código:

a, b = 10, 20 # Duas variáveis declaradas

if a<30 or b<5: # Testando as duas condições ao mesmo tempo (uma delas True)

print(a+b)

A função print() acima será normalmente executada porque uma das duas proposições (a<30) é verdadeira (True),
fazendo a operação or também ser True.

Observe, agora, este código:

a, b = 10, 20 # Duas variáveis declaradas

if a>20 or b<5: # Testando as duas condições ao mesmo tempo (as duas False)

print(a+b)

A função print() acima não será executada porque as duas proposições (a>20 e b>5) apresentadas no laço if, são
False (falsas), fazendo a operação or também ser False.

Você pode usar and e or em expressões com mais de duas proposições, como no exemplo:

if var1 < 10 and var2 > 30 and var3 == "casa":

Não esqueça que: and só é True se todas forem True; or só é False se todas forem False.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 120

32.4. Vamos Exercitar?

Analise o Código Abaixo:

quadrados=[0,1,4,9,16,25,36,49]

x=0

while x<6 and quadrados[x]==x**2:

if x>2 or quadrados[x]>20:

print("O quadrado de",x,"é",quadrados[x])

x+=1

print("Fim do Programa")

Qual é a saída do código acima?

Caso modificássemos a linha do if para <20, ao invés de >20, qual seria a saída do programa?

Considerando o código alterado pela questão anterior, qual seria a saída do programa se,
abaixo da primeira linha de código, adiconássemos a linha:
Quadrados[4]=25

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 121

33. Lista de Tuplas com o Comando zip
33.1. Voltando às Listas
Aprendemos que uma lista é uma estrutura de dados que possui várias posições (espaços) para armazenamento
de dados variados, como se fossem “gavetas” em um armário. Essas gavetas aceitam diversos tipos de dados
diferentes, inclusive outras listas (o que forma uma “lista de listas”).

lista1=[1,2,3,4]

lista2 = ["a", "b", "c", "d"]

lista3 = ["X", "Y", "Z", "W"]

lista4 = [6, 7, 8]

No exemplo acima, nós criamos:

[A] Uma lista chamada lista1 que contém 4 elementos do tipo integer.

[B] Uma lista chamada lista2, que contém 4 elementos do tipo string.

[C] Uma lista chamada lista3, que contém 4 elementos do tipo string.

[D] Uma lista chamada lista 4 que contém 3 elementos do tipo integer.

Ô João, mas uma lista

pode conter elementos
de tipos diferentes, né?

Sim, amigo leitor! Uma lista pode apresentar elementos com tipos de dados diferentes. Foi apenas uma decisão
minha, para este exemplo, colocar cada lista com apenas um tipo de dado específico.

33.2. A função zip

Se você tem duas ou mais listas (ou outros objetos iteráveis), é possível juntá-los em uma única lista por meio
de uma função chamada zip().

lista1=[1,2,3,4]

lista2 = ["a", "b", "c", "d"]

lista3 = zip(lista1, lista2) # esta linha criou um objeto zip chamado lista3

print(lista3)

Quando você usa a função zip(), você não cria uma lista: você cria um objeto do tipo zip, que é um endereço para
as posições de memória das duas listas originais. Esse tipo de objeto não pode ser exibido naturalmente... o
resultado (saída) do programa acima será:

<zip object at 0x0000021B19272780>

Ô João, eu consigo usar a função list()

para transformar esse objeto zip em uma
lista para poder vê-lo normalmente?

Sim, caro leitor! É exatamente assim que a gente possibilita o uso do resultado do zip: transformando ele em uma
lista por meio da função list().
Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 122
O código completo seria esse aqui:

lista1=[1,2,3,4]

lista2 = ["a", "b", "c", "d"]

meio_termo = zip(lista1, lista2) # esta linha criou um objeto zip meio_termo

lista3 = list(meio_termo) # aqui, converto meio_termo na lista lista3

print(lista3)

O resultado deste código é:

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

Note que cada item da lista lista3 é uma tupla entre as posições de mesmo índice das listas lista1 e lista2,
portanto, o que a função zip() faz é criar um objeto zip, que pode ser transformada em uma lista de tuplas.

33.3. Mais de Duas Listas Unidas? Sim!

A função zip() pode ser usada para unir mais de duas listas. Veja o exemplo:

lista1=[1,2,3,4]

lista2 = ["a", "b", "c", "d"]

lista3 = [9, 8, 7, 6]

meio_termo = zip(lista1, lista2, lista3)

lista4 = list(meio_termo) # aqui, converto meio_termo na lista lista4

print(lista4)

O resultado deste programa é:

[(1, 'a', 9), (2, 'b', 8), (3, 'c', 7), (4, 'd', 6)]

Note que a lista4 tem quatro itens: cada um deles é uma tupla com 3 itens, porque são 3 as listas originais (lista1,
lista2 e lista3). E todas essas 3 listas têm o mesmo número de itens (4 itens).

Ô João, a função zip() pode ser usada

para unir listas com quantidades
diferentes de elementos?

Sim, amigo leitor! No caso, a lista final terá a mesma quantidade de elementos da menor das listas originais,
criando tuplas até a posição final desta. Veja o exemplo:

lista1=[1,2,3]

lista2 = [9, 8, 7, 6, 5, 4]

lista_meio = zip(lista1, lista2, lista3)

lista_final = list(lista_meio)

print(lista_final)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 123

Note que foram zipadas duas listas: uma com 3 elementos e outra com 6 elementos. O objeto zipado (que se
tornará uma lista de tuplas) contém apenas 3 elementos, que é a quantidade apresentada pela menor das listas
originais. Todos os demais elementos da lista2 foram devidamente ignorados – apenas os 3 primeiros foram
utilizados, para combinar, cada um deles, com um dos elementos da lista1.

O resultado do código é:

[(1,9), (2,8), (3,7)]

Não esqueça que cada elemento de uma das listas zipadas combinará exatamente com o elemento que tem a
mesma posição na outra lista. Ou seja, o elemento lista1[0] fará tupla com o elemento lista2[0], o elemento
lista1[1] fará tupla com o lista2[1], e assim por diante!

33.4. Vamos Exercitar?

Analise o código a seguir:

nomes = ["Joao", "Ana", "Pedro", "Mateus", "Maria", "Clara"]

idades = [49, 50, 22, 17, 24]

idades.sort()

nomes.append("Heitor")

nomes.sort()

matriculas = zip(idades, nomes)

matriculas = list(matriculas)

print(matriculas[2], matriculas[0])

matriculas.pop()

print(matriculas)

Qual é a saída do código acima?

(não use o Python para resolver. Resolva aqui com sua mente!)

Caso você escreva um # antes da linha nomes.sort(), qual será a saída do programa?

(não use o Python para resolver. Resolva aqui com sua mente!)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 124

34. Laços de Repetição Aninhados (Nested Loops)
34.1. Laço for e Laço while
Nós aprendemos que os laços de repetição (loops) usados no Python são o laço for (para os casos em que
sabemos quantas vezes o loop se repetirá) e while (para quando não sabemos previamente quantas repetições
haverá).

Ambos são escritos mais ou menos do mesmo jeito (há algumas diferenças, claro). Vamos resumi-los:

for <variavel> in <iterável>:

comandos a serem repetidos

este comando está fora do loop for

while <condição booleana>:

comandos a serem repetidos

este comando está fora do loop while

Em muitos casos, é necessário fazer um laço for dentro de outro laço for externo, gerando, assim, repetições
(iterações) dentro de cada iteração principal. Programas mais complexos exigem esse tipo de construção.

Em outros casos, há a necessidade de colocar laços while secundários dentro de laços while mais amplos. O Céu
é o limite para o que pode ser feito com laços.

34.2. Laço for dentro de Laço for (exemplos)

Imagine que, em uma turma de 9º Ano, os alunos foram agrupados em 3 grupos de 3 alunos cada um e esta
organização foi concretizada em uma lista de listas, como a mostrada a seguir:

grupos = [["Ana", "Pedro", "Luis"],

["Carla", "Eduarda", "Raí"],

["Bernardo", "Gustavo", "Yasmin"]]

Ô João, essa forma de escrever ficou estranha...

várias linhas de texto para terminar de
escrever uma única lista? Isso funciona??

Sim, amigo leitor. Isso tudo será entendido como uma única lista, como se tivesse sido escrito em uma única
linha, porque se você abriu o [ da lista principal (logo após o sinal de =), o Python só ficará satisfeito quando
encontrar o fechamento para este colchete, esteja ele na mesma linha ou em linhas posteriores. O colchete que
fecha só é encontrado lá embaixo, depois de “Yasmin”]].

Imagine que você quer listar, linha a linha, cada participante de cada time (um nome por linha). Você pode escrever
inúmeros print(), um seguido do outro, e os dados serão escritos em linhas seguidas, um dado em cima do outro.
Mas para isso, já que temos vários nomes em uma lista e, cada lista destas dentro de uma lista maior, temos que
propor duas varreduras (uma para a lista principal e outra para as listas que estão dentro).

Para isso, criaremos um for principal para varrer a lista grupos e um for interno, para varrer (iterar) cada
elemento de cada lista que é elemento da lista grupos.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 125

 grupos = [["Ana", "Pedro", "Luis"], # Declarando a lista Grupos

["Carla", "Eduarda", "Raí"],

["Bernardo", "Gustavo", "Yasmin"]]

for grupo in grupos: # Varrendo cada grupo dentro da lista grupos

for elemento in grupo: # Varrendo cada elemento dentro do grupo

print(elemento) # Imprimindo na tela cada elemento

print("terminou o programa")

A explicação é simples:

[A] Quando o loop for principal inicia, ele vai varrer (iterar) cada elemento dentro da lista grupos, esse
elemento será chamado, a cada iteração, de grupo (variável interna desse laço for).

[B] Quando o segundo loop for inicia (a cada iteração do for superior), ele irá varrer os elementos da lista
grupo (que, a cada iteração do for superior, mudará, pois será um elemento diferente da lista grupos).

[C] A cada iteração do loop for interno, ele vai guardar o elemento na variável elemento e, então irá mostrá-
lo na tela (com a linha print(elemento), né?).

[D] Como cada print escreve seu argumento em uma linha separada, o resultado será esse:

Ana

Pedro

Luis

Carla

Eduarda

Raí

Bernardo

Gustavo

Yasmin

terminou o programa

34.3. Laço while dentro de Laço while

Apenas para lembrar, nós usamos laços while quando queremos que o loop se repita sem que saibamos
previamente quantas repetições haverá.

Eu tô tentando aqui pensar num exemplo

prático de necessidade para este while dentro
de while, mas não consegui imaginar nenhum...

Eu tenho um exemplo bom... uma tabuada (apesar de este exemplo também poder ser feito via for dentro de for).
Garanto, porém, que você encontrará muitos exemplos ao longo de sua vida de programador que vão exigir esse

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 126

tipo de estrutura em que um while precisará ser escrito dentro de outro while: não se preocupe, este aqui é só
um exemplo para demonstrar o recurso.

print(10 * "=") # Aqui, apenas um cabeçalho

print("TABUADA")

print(10 * "=")

fator1 = 1 # Aqui, declara-se a variável fator1

while fator1 <= 5: # Aqui, o primeiro loop, que itera fator1 até 5

fator2 = 0 # A cada iteração de fator1, fator2 volta a 0 (zero)

while fator2 <= 5: # Aqui, o segundo loop, que itera fator2 até 5

print(fator1, "x", fator2, "=", fator1*fator2) # Aqui, printa a frase

fator2 += 1 # Aqui, fator2 é atualizado em +1 (dentro do loop 2)

print(10 * "-")

fator1 += 1 # Aqui, fator1 é atualizado em +1 (dentro do loop 1)

print("Terminou o programa")

O resultado é o seguinte (dividi em várias colunas para poder ver tudo.

========== 2 x 3 = 6 4 x 2 = 8

TABUADA 2 x 4 = 8 4 x 3 = 12

========== 2 x 5 = 10 4 x 4 = 16

1 x 0 = 0 ---------- 4 x 5 = 20

1 x 1 = 1 3 x 0 = 0 ----------

1 x 2 = 2 3 x 1 = 3 5 x 0 = 0

1 x 3 = 3 3 x 2 = 6 5 x 1 = 5

1 x 4 = 4 3 x 3 = 9 5 x 2 = 10

1 x 5 = 5 3 x 4 = 12 5 x 3 = 15

---------- 3 x 5 = 15 5 x 4 = 20

2 x 0 = 0 ---------- 5 x 5 = 25

2 x 1 = 2 4 x 0 = 0 ----------

2 x 2 = 4 4 x 1 = 4 Terminou o programa

Vamos explicar, agora, passo a passo, o que aconteceu neste programa:

[A] Iniciou-se atribuindo o valor 1 à variável fator1.

[B] O primeiro while vai repetir seu conteúdo enquanto a variável fator1 for menor ou igual a 5.

[C] A variável fator2 tem seu valor definido como 0 (zero).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 127

 [D] O segundo while vai repetir seus comandos enquanto a variável fator2 for menor ou igual a 5.

[E] O comando interno ao segundo while manda mostrar na tela, em uma linha separada, a expressão que
mostra fator1 e fator2 sendo multiplicados.

[F] A variável fator2 é atualizada em +1. O loop do segundo while retorna ao topo para ser executado mais
uma vez se a variável fator2 ainda for menor ou igual a 5. (retorne ao item [D]).

[G] Caso a variável fator2 chegue ao valor 6, o segundo while não será mais executado e o programa desce
para a próxima linha (próximo item).

[H] A variável fator1 é atualizada em +1. O loop do primeiro while retorna ao topo para ser executado mais
uma vez se a variável fator1 ainda for menor ou igual a 5. (retorne ao item [B]).

[I] Caso a variável fator1 chegue ao valor 6, o primeiro while não será mais executado e o programa desce
para a próxima linha (próximo item).

[J] O programa imprime “Terminou o programa” na tela e termina.

Estes são apenas dois pequenos exemplos de como os laços de repetição podem ser usados de forma aninhada
(nested), um dentro do outro. Invente a sua! Esta é uma técnica fantástica!

34.4. Vamos Exercitar?

Escreva um programa que receba o nome de 20 alunos (que o usuário deve digitar) e os
organize em 5 grupos de 4 integrantes cada um. Cada grupo deve ser uma lista contendo os
nomes dos alunos. Os 5 grupos devem ser os elementos de uma lista principal.

Reescreva este mesmo programa de modo que os grupos possam ser formados por
quantidades diferentes de alunos e que não haja número definido de grupos.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 128

35. Separando e Juntando Strings
35.1. Separando Strings em Pedaços
O método .split(separador) é usado para separar uma string em várias strings menores de acordo com um
caractere separador que você determina dentro dos parênteses.

Veja o exemplo a seguir:

texto = "Pernambuco"

lista=texto.split('m')

print(texto)

print(lista)

Neste código, eu solicitei que a variável lista guardasse a separação da variável texto exatamente no caractere
separador ‘m’. Isso significa que o texto ‘Pernambuco’ será separado em duas partes, ‘Perna’ e ‘buco’. O caractere
separador (o ‘m’) será destruído para separar as duas partes.

Olha o resultado do código acima, que mostra tanto a variável texto quanto a nova variável lista.

Pernambuco

['Perna', 'buco']

Entendi, João! Quer dizer que o método .split() cria uma lista
contendo os strings separados na string original, né? Isso não
muda a string original, só cria um novo objeto lista, certo?

Exatamente! Perfeito, caro leitor! Vale lembrar uma coisa: não é necessário definir qual é o caractere separador
do .split(). Ele pode ser usado com parênteses vazios: mas isso fará ele definir que o caractere separador é o
espaço entre as palavras.

Ou seja, se você usar .split() sem nada dentro dos parênteses, ele separará a string original palavra por palavra.

texto = "Pelo Sport Tudo"

lista=texto.split()

print(lista)

O resultado deste código será:

['Pelo', 'Sport', 'Tudo']

Quando o Caractere Separador é a Última Letra...

Este é um minúsculo detalhe, mas saber dele pode poupar muitas horas de dor de cabeça enquanto você escreve
seu código: quando o caractere separador está no início ou no final da string, após a separação haverá um
caractere vazio no início ou no final da lista.

texto = "amarela"

texto2 = texto.split('a')

print(texto2)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 129

O resultado deste código mostra, como primeiro e como último elementos da lista um caractere vazio, porque o
caractere separador é ‘a’ e a letra ‘a’ é o primeiro e o último caracteres da string texto.

['', 'm', 'rel', '']

É possível fazer o .split() com caracteres de escape?

Sim! Podemos usar caracteres de escape (\t, \n, \\ e qualquer outro) como caractere separador no .split().

Vamos analisar um código onde a string é construída com aspas triplas:

texto = """Subi num pé de manga

pra pegar abacaxi

como não era tempo de morango

roubaram minha bicicleta."""

lista = texto.split("\n")

print(texto)

print(lista)

Note que o .split(“\n”) usa o caractere \n (quebra de linha) como separador. Isso significa que a lista será criada
separando cada linha do texto como elementos da lista resultante. Vamos analisar o resultado de mostrar tanto
o texto quanto a lista separada:

Subi num pé de manga

pra pegar abacaxi

como não era tempo de morango

roubaram minha bicicleta.

['Subi num pé de manga', 'pra pegar abacaxi', 'como não era tempo de morango', 'roubaram
minha bicicleta.']

As primeiras quatro linhas pertencem ao texto original, em si. A última linha, como você pode ver, é uma lista
contendo 4 elementos: cada um deles é uma das linhas do texto original.

35.2. Juntando uma Lista de Strings em uma Única String

Vamos aprender a fazer o exato contrário do .split(). O método .join() reúne os elementos de uma lista de strings
em apenas uma string, realizando exatamente o oposto que o .split() faz!

texto = ["Buscai primeiro", "o Reino de", "Deus!"]

texto2 = ' '.join(texto)

print(texto2)

Perceba uma coisa engraçada: o .join() é um método que deve ser usado no caractere “juntador”, não na lista. A
lista de strings é indicada como parâmetro do .join(), ou seja, dentro dos seus parênteses. Note que esse método
foi usado atrelado ao espaço (' '.join).para indicar que é o espaço que irá servir de “cola” para juntar os elementos
da lista texto. Ou seja, entre os trechos que serão juntados, haverá sempre um espaço em branco.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 130

Veja o resultado disso: uma única string contendo...

Buscai primeiro o Reino de Deus!

Claro que você pode usar qualquer caractere (ou conjunto de caracteres) para usar com “cola”. Vamos a outro
exemplo, agora usando uma vírgula.

alunos = ["Pedro", "Ana", "Mateus", "João", "Clara", "Davi"]

csv1 = ','.join(alunos)

print(csv1)

O resultado deste código, claro, ficará:

Pedro,Ana,Mateus,João,Clara,Davi

É muito útil juntar várias strings em uma só, especialmente separando-as por vírgulas porque este é um jeito
muito comum de trocar informações entre programas: os arquivos CSV (Valores Separados por Vírgulas). Vamos
aprender, mais adiante, como abrir e salvar arquivos (especialmente de texto simples). O formato CSV é muito
útil para isso!

Por fim, podemos usar mais de um caractere (um conjunto deles) como “cola”... aqui, o mesmo programa anterior
com essa pequena alteração:

alunos = ["Pedro", "Ana", "Mateus", "João", "Clara", "Davi"]

csv1 = ' - '.join(alunos)

print(csv1)

Usei como “juntador” o trecho espaço, traço, espaço (' – ') e o resultado foi esse:

Pedro - Ana - Mateus - João - Clara - Davi

35.3. Vamos Exercitar

Observe o código abaixo:

quote1 = "Buscai primeiro o Reino de Deus."

result = quote1.split("i")

print(result)

Qual é a saída deste programa?

Caso, na segunda linha, o parâmetro “i” fosse trocada por “e”, qual seria a saída do programa?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 131

36. Mais Edição de Strings
36.1. Métodos de Maiúsculas e Minúsculas
Há muitos recursos no Python para formatar textos (strings). Já vimos vários deles, mas agora vamos conhecer
alguns métodos úteis para maiúsculas e minúsculas.

Ei, João, método é aquela função que

é escrita como “sobrenome” de um
objeto, né? Tipo objeto.metodo()?

Exatamente, amigo leitor! Método é uma função que se escreve após o nome de um objeto específico, separado
dele por um ponto. Muito bem!

O método .lower() é usado para transformar todas as letras de uma strings em minúsculas.

O método .upper() transforma TODAS AS LETRAS DE UMA STRING EM MAIÚSCULAS.

O método .title() coloca Cada Primeira Letra De Cada Palavra Da String Em Maiúsculas.

Lembre-se de uma coisa: métodos de string não alteram as strings em si. Esses métodos apenas criam novas
strings a partir do texto das strings originais!

Ou seja, se você tiver uma string chamada texto, o método texto.upper() não altera a variável texto em si, mas
pode usar o conteúdo dela, tornando-o todo maiúsculo, para criar outra variável do tipo string.

texto = "Esta FRAse tem VÁRias LetRAS MiSTURADas"

minus = texto.lower()

maius = texto.upper()

titul = texto.title()

print(minus)

print(maius)

print(titul)

print(texto)

Note que usamos os métodos .lower(), .upper() e .title() para criar as variáveis minus, maius e titul,
respectivamente, todas a partir da variável texto (que não foi alterada por nenhum dos métodos). O resultado
deste código pode ser visto aqui:

esta frase tem várias letras misturadas

ESTA FRASE TEM VÁRIAS LETRAS MISTURADAS

Esta Frase Tem Várias Letras Misturadas

Esta FRAse tem VÁRias LetRAS MiSTURADas

36.2. Localizando Caracteres numa String

Há um método usado para strings que informa a posição da primeira ocorrência de um caractere ou se um
conjunto de caracteres em uma string. Este método se chama .find().

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 132

 texto = "Leopoldina"

print(texto.find('o'))

A expressão texto.find(‘o’) vai indicar em que posição (índice) da string se encontra a primeira aparição de uma
letra o.O primeiro o está na posição 2 da string, por isso o resultado do programa é:

O método .find() também pode ser usado para encontrar um “conjunto” de caracteres, trazendo como resposta a
posição em que o primeiro caractere do conjunto está. Veja isso:

texto = "Leopoldina"

print(texto.find('di'))

Note que mandei o Python localizar o trecho ‘di’. A letra ‘d’ está na posição 6 da string texto, logo, a saída é:

Ei, João, o que acontece quando a

gente pede para localizar um
trecho que não existe na string?

Excelente pergunta, amigo leitor! Se você usar um .find() para localizar um trecho que não existe dentro da string,
o Python responderá com -1 (1 negativo). Faça o teste.

Lembrete: o método .find() retornará o índice da posição em que se encontra, APENAS, a 1ª ocorrência do trecho
que se pede para localizar. Se houver mais de um trecho igual na string, os demais nem são analisados.

36.3. Substituindo Caracteres de uma String

Há um método no Python que pode substituir (trocar) todas as ocorrências de um determinado caractere, ou
grupo de caracteres, por outro (caractere ou grupo). Este método se chama .replace() e se escreve da seguinte
maneira: string.replace(trecho_sai,trecho_entra).

Essa é fácil, João! A palavra replace, em inglês, quer

dizer “trocar”, ou “substituir”. Então, é como dizer
“troque o <trecho que sai> pelo <trecho_que_entra>”.

Isso mesmo, meu amigo! Assim como a palavra find significa encontrar. Quem entende de inglês se dá bem no
Python, nós já mencionamos isso, né?

Veja o código a seguir, que pede para substituir as ocorrências de ‘in’ por ‘out’:

texto = "Leopoldina"

texto2 = texto.replace('in', 'out')

print(texto2)

Note uma coisa muito importante: o método .replace() não altera a string original (afinal, não é possível alterar
strings caractere a caractere, porque strings são listas imutáveis), mar serve para criar outra string a partir da
original, por isso tivemos que usar o .replace() para criar a variável texto2 no exemplo anterior.

O resultado do programa, mostrando a variável texto2 será:

Leopoldouta

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 133

Atenção: o método .replace() substitui TODAS AS OCORRÊNCIAS do texto_que_sai existentes. Ele não substitui
apenas uma! Ele não permite escolher “qual” vai ser substituída. Ele sempre substitui todas!

Veja um exemplo disso neste código:

texto = "Araraquara"

texto2 = texto.replace('a', 'e')

print(texto2)

Arerequere

36.4. Limpando Strings com .strip()

Cuidado para não confundir! Aprendemos, na lição passada, a usar o .split() para separar strings usando um
caractere especial como separador. Agora, usaremos o .strip() para “limpar” strings (eu dei esse alerta porque
são palavras muito parecidas e eu mesmo já me confundi várias vezes).

Imagine um texto que é tirado de um banco de dados, um arquivo CSV (veremos isso mais adiante) ou uma
planilha, como o Microsoft Excel ou o Google Planilhas... Às vezes os dados são recebidos pelo Python, mas eles
não são “super limpos” (alguns possuem espaços ou outros caracteres no seu início e/ou no seu final).

O método .strip() remove todos os espaços iniciais e finais de uma string, gerando um resultado que deverá ser
colocado em outra variável.

texto = " Tomás de Aquino "

texto2 = texto.strip()

print(texto2)

Veja que a string texto apresenta inúmeros espaços no início e no final. O resultado do .strip() é:

Tomás de Aquino

O método .strip() também pode ser usado para retirar outros caracteres (não apenas espaços) que estão no início
e/ou no fim da string, desde que você o indique dentro dos parênteses:

texto = "####Tomás de Aquino###"

texto2 = texto.strip('#')

print(texto2)

Veja que a string texto tem vários # no início e no final. O resultado do .strip('#') é:

Tomás de Aquino

36.5. Exercitando

Escreva um código que substitua os três primeiros caracteres e os três últimos caracteres de
uma string por três espaços em cada... depois limpe a string resultante, retirando esses
espaços.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 134

37. Mexendo com Números Aleatórios
37.1. Lembrando Módulos
No Python, algumas funções e variáveis podem ser guardadas em arquivos separados daqueles arquivos que
contêm os códigos que construímos. Esses arquivos “extra” são chamados de módulos (modules).

A gente importa módulos para dentro do nosso código quando precisa se referir aos objetos que estão dentro
desses módulos, sem precisar ter que criá-los do zero. O Python tem milhares de módulos disponíveis que você
pode usar “importando-os” para dentro do seu programa... vamos lembrar algumas maneiras de importá-los?

Importando o Módulo Todo com import modulo

import random # importa o módulo chamado random

numero = random.randint(1,100) # usa a função randint que está em random

Neste caso, sempre que formos nos referir a um objeto (função ou variável) que está dentro do módulo que foi
importado, devemos sempre nos referir a ela como modulo.objeto(), como foi feito em random.randint().

Importando o Módulo Todo com import modulo as apelido

import random as ra # importa o módulo chamado random e apelida de ra

numero = ra.randint(1,100) # usa a função randint que pertence a ra

Neste caso, apenas damos um apelido “mais curto” para a palavra random, para que a nossa digitação seja mais
rápida (só vamos precisar usar ra como prefixo das funções e variáveis).

Importando Objetos Específicos de um Módulo

from random import randint # importa só a função randint do módulo random

numero = randint(1,100) # usa a função randint diretamente (ela foi “trazida”)

Quando a gente importa apenas os objetos (não o módulo todo), os objetos são trazidos para “dentro” do código e
isso faz com que possam ser referenciados diretamente sem precisar de prefixos. Por isso foi possível se referir
à função randint() diretamente, sem precisar fazer random.randint().

Não esqueça de que também é possível:

- importar todos os objetos de um módulo, usando from modulo import *;

- importar um objeto específico e dar-lhe um apelido, usando from modulo import objeto as apelido. Neste caso,
sempre que formos usar o objeto, nos referiremos a ele pelo apelido.

Use estas dicas sempre que quiser, se quiser, é claro!

João, na prática, existe alguma diferença

entre importar o módulo todo ou importar
somente um objeto ou “tanto faz”?

Tem diferença sim, amigo leitor! Às vezes, o módulo é muito grande (tem muitas funções) e, se você não vai usar
todas elas, não vale a pena importar o módulo todo! (seu programa vai ficar mais lento e sem necessidade!).

É preferível, portanto, que você importe somente os objetos (funções e/ou variáveis) que você vai efetivamente
usar em seu código!

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 135

37.2. Módulo random
Para trabalhar com números aleatórios (“sorteios”), é necessário importar o módulo random (random significa
“aleatório” em inglês) ou algumas de suas funções. Vamos conhecer duas delas: a randint() e a choice().

A Função randint(a,b)

A função randint(a,b) escolhe um número inteiro (integer) aleatório entre os dois números limites apresentados
como argumentos (a e b), inclusive os próprios limites (perceba que diferente da função range(), a função
randint() foi construída para incluir o valor final na resposta).

Veja o código a seguir:

from random import randint

numero = randint(1, 6) #Escolhe um número inteiro entre 1 e 6 (inclusive)

print(numero)

Basta atribuir a uma variável a função randint apontada para os números-limite. O resultado deste código acima
pode ser 1, 2, 3, 4, 5 ou 6 (o Python é quem vai escolher “na sorte”).

A função choice(seq)

A função choice(seq) escolhe um elemento aleatório a partir de um objeto sequência (lista, tupla, iterável,
range() etc.). Basta atribuir a uma variável a função choice que esta variável vai guardar um dos itens, escolhido
pelo próprio Python.

from random import choice as esc # A função choice() se chama, agora, esc()

alunos = ["Pedro", "Ana", "Mateus", "João", "Clara", "Davi"]

ganhador = esc(alunos) # Chamei a função esc e a apontei para a lista alunos

print(ganhador)

No código acima, [A] importei a função choice() apelidando-a de esc(); [B] defini o objeto alunos como uma lista
de strings; [C] defini que a variável ganhador vai guardar UM DOS NOMES, escolhidos pela função esc(), que
pertencem à lista alunos; [D] mandei mostrar o ganhador.

O resultado será um desses: Pedro, Ana, Mateus, João, Clara ou Davi. (o Python escolherá)

A função sample()

A função sample() é usada para gerar uma amostra (um grupo de dados) aleatória a partir de uma população
(um grupo de dados maior, uma sequência, como um range, uma lista, uma tupla ou uma string) sem repetir
elementos nesta amostra.

A forma de escrita da função sample() é sample(população, quantidade), onde quantidade informa quantos
elementos terá a amostra aleatória desejada. Veja este código:

from random import sample

pop = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196]

amostra = sample(pop, 6) # Gera 6 itens aleatoriamente escolhidos de pop

print(amostra)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 136

O código anterior vai escolher aleatoriamente 6 elementos da lista pop e guardá-los (como uma lista), na variável
amostra. O resultado deste código varia muito, já que a escolha dos itens da amostra é aleatória, mas aqui, quando
eu rodei, deu esse resultado:

[100, 4, 144, 36, 169, 9]

A função sample pode ser usada em qualquer tipo de objeto sequência, como range, lista, tupla ou string... o seu
resultado (seu retorno) sempre será uma lista!

Quando a função sample() é usada apontando para uma string, os elementos que ela seleciona são os caracteres
daquela string.

from random import sample

pop = "Pernambuco de Meus Pais"

amostra = sample(pop, 6) # Gera 6 itens aleatoriamente escolhidos de pop

print(amostra)

É difícil dizer qual resultado este programa irá dar... porque a sample() seleciona aleatoriamente... mas aqui,
quando o rodei, deu isso aqui:

['a', 'e', 'o', 'P', ' ', 's']

Um erro bem simples que pode ocorrer quando usamos a função sample() é solicitar um número maior de itens
na amostra que a quantidade de elementos da população original.

from random import sample

pop = [8, 3, 4, 2] # A população tem apenas 4 elementos

amostra = sample(pop, 6) # Tento gerar 6 itens na amostra (impossível)

print(amostra)

O Python vai apresentar este erro:

ValueError: Sample larger than population or is negative

Ou seja, “a amostra é maior que a população, ou a amostra é negativa”.

37.3. Exercitando Números Aleatórios

Crie um programa que receba do usuário vários nomes seguidos e, depois de terminar de
inserir todos, o programa escolha um dos nomes aleatoriamente. Sim, é um programa para
fazer um sorteio entre os diversos nomes inseridos anteriormente.

Modifique, depois, o programa para que ele escolha, dentre todos os alunos inscritos, um
grupo contendo 4 indivíduos para serem os representantes da sala.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 137

38. Usando o Módulo decimal
38.1. Float – Problemas Curiosos
Quem já realizou somas e outras operações com números float enfrentou, algumas vezes, respostas estranhas
em relação ao que se esperava. Perceba o código a seguir:

a = 0.10

b = 0.35

c = a + b # Esta soma vai dar um resultado estranho...

print(c)

Você pode achar que o resultado vai ser um simples 0.45, porque a soma entre 0.10 e 0.35 é bem simples de fazer
e não teria por que dar outro resultado, mas você se surpreender! O resultado deste programa é, por mais incrível
que pareça, este aqui:

0.44999999999999996

Esses erros se devem à forma como o Python representa, em binário, os números de ponto flutuante. Ou seja, o
problema está na forma como os números float são armazenados na memória pelo Python (esses erros também
são cometidos em outras linguagens de programação).

38.2. O módulo decimal

Se você quiser corrigir este problema, deverá usar (importar) a função Decimal() (sim, com a letra D maiúscula)
que pertence ao módulo decimal (todas em minúsculas).

A função Decimal(string) deve ser usada em uma string que possa ser convertida em um número float exato,
que apresenta o mesmo número de casas decimais existentes na string.

from decimal import Decimal as dec # A função Decimal agora se chama dec()

a = dec('0.10') # Convertemos a string em Float exato

b = dec('0.35') # Convertemos a string em Float exato

c = a + b

print(c)

O resultado deste programa é:

0.45

Não esqueça de uma coisa: o argumento da função Decimal() tem que ser, necessariamente, uma string!

38.3. Vamos Exercitar?

Escreva um programa que receba dois dados do usuário (números float) e realize a soma
entre eles dois, retornando um número com apenas 2 casas decimais, não importando
quantas casas decimais o usuário tenha digitado originalmente.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 138

39. Mais sobre Dicionários
39.1. Recordando Dicionários
Lá na lição 18, nós aprendemos o que é um dicionário, que tal rever agora?. Um dicionário (ou dictionary, em
inglês) é uma estrutura de dados que permite armazenar múltiplos dados (como listas e tuplas) associando duas
informações: uma chave e um valor.

No dicionário, a chave atua como índice (serve para indicar uma posição dentro do dicionário) e o valor é o dado
guardado naquela posição. No dicionário, cada dupla chave:valor é escrita exatamente assim, separados por um
sinal de : (dois-pontos).

Para delimitar os dados de um dicionário, usamos { } (chaves) e os separamos por vírgulas. Eis um exemplo:

dic = {'Nome':'João', 'Idade': 50, 'Turma': 12, 1:7.5, 2:8.5, 3:10.0}

39.2. Dicionários e Tipos de Dados

Note que este dicionário tem 6 entradas (elementos). Vamos analisar cada uma delas:

A primeira entrada tem chave no formato string (‘Nome’) e valor também em string (‘João’). A segunda entrada
tem chave em formato string (‘Idade’) e valor em formato integer (50). A terceira tem os mesmos tipos de dados
da segunda. As três últimas entradas do dicionário possuem chaves em formato integer e valores em formato
float.

Isso quer dizer que tanto chave

quanto valor podem assumir
qualquer tipo de dados, João?

Os valores, sim, podem assumir qualquer tipo de dados, inclusive listas, tuplas e até mesmo outros dicionários
(sim, dicionários dentro de dicionários). Mas as chaves não! As chaves só podem ser strings, números ou tuplas:
as chaves não podem conter listas ou dicionários.

Se você tentar rodar um código em que cria um dicionário contendo uma chave do tipo lista (que é inválida), como
o código a seguir, em que a lista [1,2,3] é a chave da primeira entrada...

dic = {[1,2,3]:"filhos", 4: "pai", 5:"mãe")

print(dic)

O Python apresentará o seguinte erro:

TypeError: unhashable type: 'list'

39.3. Adicionando Múltiplos Dados a um Dicionário

Lá na lição 18, a gente aprendeu a acionar novos dados a um Dicionário: basta atribuir ao dicionário uma nova
chave como dicionário[nova_chave]=novo_valor. Veja a seguir o código:

dic = {3:"filhos", 4: "pai", 5:"mãe"} # Dicionário com apenas 3 entradas

dic[2]="avó" # Mencionando uma Entrada inexistente (vai adicionar)

Depois do comando dic[2]= "avó", o dicionário dic passou a ter 4 entradas. Ao printá-lo, fica assim:

{3: 'filhos', 4: 'pai', 5: 'mãe', 2: 'avó'}

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 139

Este método, porém, só serve para adicionar apenas UMA ENTRADA nova. Caso você queira adicionar várias
entradas de uma única vez, poderá usar o método .update(), associado ao dicionário.

dic = {3:"filhos", 4: "pai", 5:"mãe"} # Dicionário com apenas 3 entradas

dic.update({1:"avô", 2:"avó"}) # Usando update() para adicionar mais 2

print(dic)

É claro que o resultado deste código será:

{3: 'filhos', 4: 'pai', 5: 'mãe', 1: 'avô', 2: 'avó'}

Ei, João, eu percebi que as duas novas entradas que você adicionou pelo
uptade() tinham chaves diferentes das já existentes no dicionário. O
que acontecerá se você usar chaves que já existem lá dentro?

A entrada que possui aquela chave irá ser substituída pela entrada nova, ou seja, o valor dela será modificado.

dic = {3:"filhos", 4: "pai", 5:"mãe"} # Dicionário com apenas 3 entradas

dic.update({3:"avô", 4:"avó"}) # Usando update() para modificar 3 e 4

print(dic)

Daí, é claro, fica assim:

{3: 'avô', 4: 'avó', 5: 'mãe'}

39.4. List Comprehensions, Zip e Dicionários... Dá Match?

É possível criar dicionários a partir de expressões regulares (List Comprehensions) de forma mais ou menos
parecida com a que usamos para criar listas. Veja o código a seguir:

nomes = ['Ana', 'Pedro', 'Mateus', 'João'] # Primeira Lista, 4 elementos

notas = [9.3, 9.1, 9.5, 8.7] # Segunda Lista, 4 elementos

alunos_notas={chave:valor for chave,valor in zip(nomes,notas)} # Presta atenção!

print(alunos_notas)

No código acima, foram criadas duas listas com 4 elementos cada. Note, na terceira linha do código, que estamos
criando um dicionário chamado alunos_notas (é um dicionário porque sua expressão lógica está envolvida por
chaves { }, percebeu?).

Pois bem, ao começar a expressão com chave:valor, estou informando que o conteúdo deste dicionário estará
neste formato. Ao continuar com for chave, valor in, eu determino de onde ele puxará os dados chave e valor
para preencher as entradas do dicionário. Por fim, ao indicar zip(nomes, notas), eu determino que as duas listas
criadas anteriormente serão “fundidas” em um objeto ZIP e este objeto juntará o dado [0] de uma lista com o dado
[0] da outra, o dado [1] com dado [1] e assim por diante...

A leitura desta linha de código é mais ou menos assim: “crie um dicionário chamado alunos_notas que tenha os
elementos chave:valor trazidos do objeto ZIP criado da junção das listas nomes e notas”. O resultado é um
dicionário assim:

{'Ana': 9.3, 'Pedro': 9.1, 'Mateus': 9.5, 'João': 8.7}

Muito legal, né?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 140

39.5. Buscando Dados com Chaves Inválidas
Nós já sabemos que, para acessar um dado específico num dicionário, temos que apontar para a chave desejada
da forma dicionário[chave_desejada].

familia = {"avô":89, "avó":86, "pai":59, "mãe":60, "irmão":32}

print(familia["pai"])

O código acima irá imprimir apenas o valor 59, que é o valor associado à chave “pai” do dicionário familia.

Mas, se solicitarmos uma chave que não existe no dicionário? Se, em alguma parte do nosso código, for solicitada
a um dicionário uma chave que não está lá?

familia = {"avô":89, "avó":86, "pai":59, "mãe":60, "irmão":32}

print(familia["tio"])

É claro que isso vai dar erro, né?

KeyError: 'tio'

Para evitar que o programa pare por algum erro deste tipo (que pode acontecer especialmente se você deixar
que o usuário escolha qual chave pesquisar), você pode usar o método .get(). Ele pode ser escrito na forma de
dicionário.get(chave_desejada) e tem várias vantagens em relação ao formado dicionário[chave_desejada].

Ao usar o método .get(), em primeiro lugar, não será apresentado nenhum erro caso a chave desejada não exista.
Aliás, é possível até informar qual mensagem o usuário receberá, sem que, com isso, o programa pare.

familia = {"avô":89, "avó":86, "pai":59, "mãe":60, "irmão":32}

saida1 = familia.get("mãe") # Aqui, o retorno será 60, pois achamos “mãe”

saida2 = familia.get("tio", "Não encontrado") # Aqui, a chave “tio” não existe

print(saida1)

print(saida2)

No código acima, a linha que pede o .get(“mãe”) vai colocar o número 60 na variável saida1, porque 60 é o valor
associado à chave “mãe” do dicionário familia. Porém, na linha em que o .get() pede “tio”, o retorno será “Não
encontrado”, porque esta foi a string que colocamos no segundo argumento da .get() – este segundo argumento
é justamente a mensagem que é dada ao usuário caso haja erro em achar a chave desejada (no caso, “tio”).

O resultado dos dois prints solicitados acima é:

60

Não encontrado

39.6. Apagando uma Entrada do Dicionário

Já aprendemos como criar novas entradas num dicionário. Também aprendemos a modificar os valores e acessar
os valores de uma determinada chave_desejada. Agora, chegou a vez de apagar uma entrada de um dicionário.
Para isso, claro, precisamos saber qual é a chave da entrada que desejamos apagar.

Use o método .pop(). Ele é utilizado assim: dicionário.pop(chave_desejada). O método .pop() assim como o
método .get(), pode receber um segundo argumento que é justamente a mensagem que o usuário receberá caso
a chave_desejada não seja encontrada no dicionário.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 141

 familia = {"avô":89, "avó":86, "pai":59, "mãe":60, "irmão":32}

saida1 = familia.pop("mãe") #Aqui, a entrada da chave “mãe” será apagada

saida2 = familia.pop("tio", "não encontrado") # Aqui, a chave “tio” não existe

print(saida1) # O nome “mãe” estará aqui na variável saida1

print(saida2)

print(familia)

O método .pop() não só apaga uma chave... ele também retorna o valor associado à chave_desejada, por isso o
programa trará, como resultado:

60

não encontrado

{'avô': 89, 'avó': 86, 'pai': 59, 'irmão': 32}

Note que o programa retornou o 60 (valor associado à chave “mãe”) e a apagou. Podemos ver isso no dicionário
impresso na tela: ele não tem mais a chave “mãe”.

João, mas tanto o .pop() quando o .get()

precisam que eu saiba o nome da chave que
eu quero.. E se eu não souber? O que faço?

Ahá! Excelente pergunta, amigo leitor! Estava esperando que você a fizesse!

39.7. Listando Todas as Chaves num Dicionário

Caso você queira listar todas as chaves existentes em um dicionário, você pode usar o método .keys(). Este
método retorna um objeto do tipo dict_keys (que é um objeto “conjunto de chaves”), que não pode ser alterado:
você não pode adicionar, modificar ou apagar elementos de um objeto deste tipo.

O objeto criado pelo método .keys() pode ser usado como iterável em um laço for, o que permite construir um
código como esse:

familia = {"avô":89, "avó":86, "pai":59, "mãe":60, "irmão":32}

chaves = familia.keys() # Cria o iterável chaves, contendo as chaves de familia

for chave in chaves: # Itera cada chave dentro do objeto chaves

print(chave) # Imprime, em uma linha separada, cada chave

O resultado deste código é:

avô

avó

pai

mãe

irmão

Há um outro jeito de conhecer todas as chaves de um dicionário sem precisar usar laço for.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 142

Você pode, simplesmente, converter o dicionário em uma lista, usando a função list(). Quando um dicionário é
convertido em lista, somente as chaves viram elementos das listas (os valores não vão). Veja o código;

fam = {"avô":89, "avó":86, "pai":59, "mãe":60, "irmão":32} # fam é um dicionário

fam2 = list(fam) # Aqui, criei uma lista fam2 convertendo a partir de fam

print(fam2) # Aqui, printei fam2 (a lista)

O resultado do código é, simplesmente, uma lista contendo apensa as chaves vindas do dicionário fam.

['avô', 'avó', 'pai', 'mãe', 'irmão']

Legal, né?

39.8. Listando Todos os Valores num Dicionário

Já aprendemos como listar todas as chaves de um dicionário. Mas e se quisermos listar todos os valores? Existe
o método .values(), que gera um objeto do tipo dict_values (que é, acho que você já deduziu, um objeto do tipo
“conjunto” que contém só os valores do dicionário). Ou seja, o que o método .keys() faz com as chaves, o
método .values() faz com os valores.

familia = {"avô":89, "avó":86, "pai":59, "mãe":60, "irmão":32} # Dicionário

valores = familia.values() # Criei o objeto valores a partir de familia

for valor in valores: # Itera cada valor dentro de valores

print(valor) # Imprime o valor da iteração atual em uma linha separada

O resultado, como você espera, é:

89

86

59

60

32

Ei, João, tem algum método para listar diretamente chave e valor,
juntos, como uma tupla, uma lista de listas, ou coisa parecida, sem
ter que fazer chave e valor separados? Vai, diz que tem... por favor...

Seu pedido é uma ordem, meu amigo leitor...

39.9. Listando Todas as Entradas (Chave, Valor) num Dicionário

Os dicionários possuem um método chamado .items() que retorna um objeto do tipo dict_list, que pode ser
convertido em uma lista de tuplas. Cada tupla tem o formato (chave, valor) a partir das chaves e valores do
dicionário que originou a lista. Veja o exemplo:

familia = {"avô":89, "avó":86, "pai":59, "mãe":60, "irmão":32} # Dicionário

objeto = familia.items() # Converti em um objeto do tipo dict_list

print(list(objeto)) # Antes de printar, converti o objeto para uma lista

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 143

O resultado do código é a impressão, na tela, de uma lista contendo elementos (chave, valor) – tuplas. Ou seja, o
resultado é uma lista de tuplas.

[('avô', 89), ('avó', 86), ('pai', 59), ('mãe', 60), ('irmão', 32)]

Eita, João, esta lição foi bem grandinha,

ein? Tem mais alguma coisa sobre
dicionários que precisamos aprender?

Não, caro leitor, não se preocupe! É verdade que sempre há mais coisa para se estudar... nunca se conhece 100%
acerca de qualquer assunto, mas o que vimos até agora dá para começarmos bem a trabalhar com dicionários
no Python! Bons estudos! Boas Codificações!

39.10. Vamos Exercitar Dicionários?

Escreva um programa que receba Nome e Idade de um número incerto de pessoas e as

guarde em um dicionário onde o Nome será a chave a Idade será o valor. O programa deve
ter a opção de adicionar e apagar pessoas. O programa também tem que ter a opção de
mostrar todas as pessoas e suas idades, uma em cada linha, por meio da frase “<Pessoa> tem
<idade> anos de Idade”.

(até o programa que eu pedi neste exercício é grande... eu sei! Você já consegue trabalhar com códigos mais
pesados... você verá!)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 144

40. Trabalhando com Arquivos de Texto
40.1. Por que Arquivos?
Até agora, quando você termina um programa Python, os dados armazenados pelas variáveis do programa são
perdidos quando você termina a execução do seu código. Cada nome que você digita, cada variável que você
atribui, cada valor que você armazena em uma lista ou tupla: tudo morre e a cada execução do programa, você
precisa digitar de novo...

Programas (aplicativos) guardam suas informações em arquivos (é isso que você faz quando salva, por exemplo).
Um programa feito em Python pode permitir que você salve e abra arquivos contendo dados que podem ser
manipulados pelo programa.

Um arquivo, portanto, é uma informação que foi salva em uma memória permanente (disco, pendrive, cartão de
memória) e lá se mantém gravado mesmo quando o computador é desligado.

40.2. A função open()

Sempre que precisarmos usar um arquivo (cujo conteúdo é texto simples), nós usamos a função open(). Esta
função precisa ser escrita assim: with open(‘nome_do_arquivo’) as apelido_interno. Vamos tomar por exemplo
um arquivo de texto chamado mensagem.txt com o seguinte conteúdo:

Subi num pé de manga

pra tirar abacaxi,

Como não era tempo de morango,

roubaram minha bicicleta

O nosso código é esse:

with open('mensagem.txt') as msg: # Abri o arquivo mensagem.txt como msg

texto = msg.read() # Pedi para ler o conteúdo dele e colocar em texto

print(texto)

A gente começa estabelecendo a conexão com o arquivo usando with open(‘mensagem.txt’) as msg:, e todos os
comandos dentro deste bloco estarão vinculados a esta conexão. O objeto msg é o apelido para esta conexão com
o arquivo mensagem.txt.

O único comando que colocamos no bloco foi texto = msg.read(), que lê o conteúdo do objeto msg (por causa do
método .read()) e o coloca dentro da variável texto.

Não esqueça! O método .read() lê TODO O CONTEÚDO de um objeto do tipo arquivo.

O resultado deste código, que manda imprimir na tela a variável texto, é:

Subi num pé de manga

pra tirar abacaxi,

Como não era tempo de morango,

roubaram minha bicicleta

Perceba que os caracteres especiais (letras com acentos, como é e ã) não foram vem interpretados pelo Python
e causaram os “defeitos” em pé (que deveria ser pé) e não (que deveria ser não). Isso é fácil de resolver.
Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 145
Basta usar o argumento encoding=”utf-8” na função open(), como mostrado no código a seguir. UTF-8 é uma
codificação de caracteres que representa todos os caracteres de várias linguagens do mundo, inclusive o
português, de modo a representar corretamente as nossas letras acentuadas. UTF-8 é a codificação mais aceita
mundialmente na Internet.

with open('mensagem.txt', encoding="utf-8") as msg: # usando o encoding="utf-8"

texto = msg.read()

print(texto)

O resultado deste código é:

Subi num pé de manga

pra tirar abacaxi,

Como não era tempo de morango,

roubaram minha bicicleta

40.3. Iterando um Arquivo Linha por Linha

O método .read() lê, de uma só vez, o conteúdo inteiro de um arquivo, não importando o seu tamanho. Ele permite,
apenas, que todo o conteúdo de um arquivo seja armazenado como uma única string dentro de uma variável.

Mas, e se você precisar colocar cada linha de um arquivo de texto em uma variável separada? Se for necessário
ler o arquivo não como uma coisa só, mas separando o seu conteúdo linha por linha? O método ideal para fazer
isso é o método .readlines().

O método .readlines() retorna um iterável que pode ser usado em um laço for, conforme o exemplo abaixo:

# Estou usando, para este código, o mesmo arquivo de texto

lista=[] # Criei, aqui, uma lista vazia

with open('mensagem.txt', encoding="utf-8") as msg: # Abri o arquivo

for linha in msg.readlines(): # O laço for criará uma variável linha na iteração

lista.append(linha) # Adiciona a linha na lista

print(lista) # Imprime na tela a lista toda

O resultado deste código é uma lista contendo cada linha do arquivo mensagem.txt como sendo um elemento
separado na lista. Veja:

['Subi num pé de manga\n', 'pra tirar abacaxi,\n', 'Como não era tempo de morango,\n',
'roubaram minha bicicleta\n']

Ei, João, no final de cada linha do arquivo dá para ver

o caractere de quebra de linha (\n). Posso retirá-lo
usando o método .strip() antes de guardá-lo na lista?

Sim, caro leitor! Muito boa a sua ideia. Ao juntar tudo o que aprendemos, você pode fazer programas muito mais
bonitos e com resultados mais agradáveis! O CÉU é o limite! Não deixe de revisitar todos os conhecimentos que
você ganhou enquanto estuda este material!

Vamos continuar avançando nos métodos usados com arquivos no Python.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 146

40.4. Lendo Apenas UMA Linha do Arquivo
Também é possível ler apenas uma linha do arquivo, sem precisar ler ele todo de uma vez. O método que faz isso
é .readline(). Ele deve ser usado como qualquer método: arquivo.readline().

Uma coisa muito interessante que o método .readline() faz é que a cada vez que ele é usado, ele lê a próxima
linha do arquivo, ou seja: se você o usa apenas uma vez, ele lê a primeira linha do arquivo; se você o usa uma
segunda vez, agora ele vai ler a segunda linha do arquivo; quando você o utiliza uma 3ª vez, ele vai ler a 3ª linha
do arquivo, e assim por diante.

Veja o código a seguir:

#Estou usando, para este código, o mesmo arquivo de texto

with open('mensagem.txt', encoding="utf-8") as msg:

primeira = msg.readline() # Aqui, captura-se a 1ª Linha do arquivo

segunda = msg.readline() # Aqui, a segunda linha é capturada

terceira = msg.readline() # Aqui, a 3ª linha foi lida e armazenada

print(segunda)

print(primeira)

print(terceira)

O resultado deste código é:

pra tirar abacaxi,

Subi num pé de manga

Como não era tempo de morango,

Mas, João... é impressão minha ou esta

saída do programa tem uma linha
vazia a mais entre cada linha de texto?

Não é impressão, caro leitor! Você está certo! Isso ocorreu porque [A] cada linha extraída do arquivo original tem
um caractere \n no final (ele cria uma “nova linha”) e [B] cada linha foi colocada na tela por uma função print()
diferente, e cada função print() é escrita em uma nova linha separada... juntando essas duas “instruções” que
mandam descer uma linha, deu nisso!

Dá para corrigir isso de duas maneiras: ou você usa print(segunda, primeira, terceira), como argumentos de
uma única função print() – desta forma, somente os caracteres \n gerarão novas linhas; ou você limpa os
caracteres \n usando o método .strip() antes de mandar printar separadamente.

40.5. Escrevendo (Salvando Dados em um) Arquivo

“Nem só de LER arquivos vive o homem!” – é necessário, também, que possamos gravar dados em um arquivo,
ou seja, precisamos poder salvá-los, afinal de contas, se eu vou ler um arquivo, é porque ele já está salvo, né?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 147

Há duas maneiras de “escrever” em um arquivo: uma delas substitui completamente o conteúdo anterior,
apagando tudo; a outra maneira permite apenas adicionar texto a um arquivo que já possui conteúdo, mais ou
menos como o método .append() faz com listas, por exemplo.

O que diferencia os dois é o parâmetro extra que deve ser passado na função open():

- Se o parâmetro ‘w’ for passado, você quer reescrever o arquivo todo, apagando completamente o conteúdo
anterior e substituindo-o pelo conteúdo que você está escrevendo agora.

- Se o parâmetro ‘a’ for passado (‘a’ de ‘append’), você quer adicionar ao conteúdo já existente no arquivo aquele
trecho de string que você manda escrever, fazendo, apenas, o arquivo “crescer” com o seu novo conteúdo.

Vamos imaginar o seguinte arquivo chamado contricao.txt:

Senhor meu, Jesus Cristo, Deus e homem verdadeiro, Criador e Redentor meu!

Por serdes vós quem sois, sumamente bom e digno de ser amado sobre todas as coisas;

e porque vos amo e estimo, pesa-me, Senhor, de todo o meu coração por vos ter ofendido.

Pesa-me também por ter perdido o céu e merecido o inferno.

Mas proponho firmemente, ajudado com o auxílio de vossa divina graça,

emendar-me e nunca mais vos tornar a ofender.

E espero alcançar o perdão das minhas culpas, pela vossa infinita misericórdia.

Amém.

Observe o código que seria usado para substituir o conteúdo inteiro deste arquivo:

#Perceba o 'w' como parâmetro da função open()

with open('contricao.txt', 'w', encoding="utf-8") as cont:

cont.write("Novo Conteúdo do Ato de Contrição") # Escrevemos com .write()

Sempre escrevemos no arquivo o conteúdo desejado com o método .write(), dentro do bloco open() que recebeu
'w' ou 'a'. Neste caso, como o ‘w’ foi usado, é correto afirmar que aquele arquivo contricao.txt terá seu antigo
conteúdo inteiro substituído por, apenas, o que está no argumento do método .write(). O arquivo contrição ficará,
portanto, assim:

Novo Conteúdo do Ato de Contrição

Se, porém, você usar o argumento ‘a’ na função open(), o conteúdo que você escrever no arquivo será “anexado”
ao que já havia, ou seja, será apenas adicionado (nenhum conteúdo anterior no arquivo será apagado). Observe
este código:

with open('contricao.txt', 'a', encoding="utf-8") as cont:

cont.write("Meu Deus, eu me arrependo de todo coração")

O parâmetro da função open() agora é 'a'. O conteúdo presente no método .write() será adicionado ao arquivo
contricao.txt, deixando ele assim:

Novo Conteúdo do Ato de ContriçãoMeu Deus, eu me arrependo de todo coração

Estranho, né? “ContriçãoMeu” ficou tudo junto... isso é porque, ao adicionar conteúdo, ele fica exatamente depois
do último caractere do texto já existente no arquivo. Imagina um jeito de corrigir isso, amigo leitor?

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 148

 Eu acho que o ideal é colocar um
\n antes da expressão que se
adiciona ao texto do arquivo, né?

Sim, se você quiser colocar o texto novo na linha abaixo do conteúdo original. Mas você pode colocar também um
simples ‘ ‘ (espaço) ou um \t (tabulação) para separar o conteúdo antigo do novo na mesma linha de texto.

Tá vendo? Tem muita opção para você corrigir o resultado do seu programa. Bora tentar?

with open('contricao.txt', 'a', encoding="utf-8") as cont:

cont.write("\nMeu Deus, eu me arrependo de todo coração") #Agora tem \n

Isso resultará em:

Novo Conteúdo do Ato de ContriçãoMeu Deus, eu me arrependo de todo coração

Meu Deus, eu me arrependo de todo coração

João, só uma última coisinha que eu fiquei me

perguntando nessa lição toda... por que usamos o
laço with? Ele é obrigatório para manipular arquivos?

Não, ele não é obrigatório para trabalhar com arquivos. Podemos abrir e fechar arquivos sem precisar do laço
with. Veja um exemplo de código que abre uma conexão com um arquivo, escreve adicionando dados a ele e fecha
a conexão em seguida:

objeto = open('contricao.txt', 'a', encoding="utf-8") # Abrimos a conexão

objeto.write("\nMais uma linha") # Escrevemos no arquivo.

objeto.close() # Este comando de fechar a conexão é necessário!

Sempre que abrimos uma conexão com um arquivo (a primeira linha chama essa conexão de objeto, uma variável,
um apelido), usando a função open(), somos obrigados a fechar a conexão quando terminarmos de usá-la: isso é
feito na última linha, com o método .close(). Entre o open() e o close() podemos escrever inúmeros comandos de
manipulação do arquivo!

O with, porém, cria um laço, um bloco de comandos, em um contexto próprio, como se criasse um “mini ambiente”
só para aquele propósito (a manipulação do arquivo que foi aberto pelo open()). Quando o programa sai do laço
with, ele já fecha o arquivo automaticamente, sem precisar do .close(). Usar o with, portanto, é mais seguro, mais
garantido.

Resumindo: não é obrigatório usar o with para manipular arquivos, mas é recomendável!

40.6. Vamos Exercitar?

Escreva um programa que receba Nome, Idade e E-mail de um número incerto de usuários e,
depois, os grave de uma vez num arquivo de texto. Cada registro de usuário deve estar em
uma linha diferente do arquivo com o seguinte formato: Nome; Idade; Email (separados por
ponto-e-vírgula)

(esse é caprichado, ein? Note: a gravação do arquivo deve ser feita somente se o usuário pedir, no final de todo o
processo de preenchimento dos dados... não vá atualizando o arquivo à medida que novos registros são
adicionados, não!)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 149

41. Trabalhando com Arquivos CSV
41.1. Arquivos CSV (Valores Separados por Vírgulas)
Um tipo de arquivo de texto muito útil para a troca de dados entre aplicativos. Nele, os dados são registrados em
linhas separadas e, dentro da mesma linha, os dados diferentes são separados por um caractere especial,
normalmente uma vírgula (dãããã... jura?). Não deve haver espaços antes nem depois do caractere separador!

Num arquivo CSV, a primeira linha descreve o cabeçalho do arquivo, indicando quais são os tipos de dados que
estão armazenados nele. Veja um exemplo de arquivo deste tipo chamado clientes.csv:

Nome,Idade,Email

Joao Gomes,48,[email protected]

Ana Senna,49,[email protected]

Pedro Carvalho,21,[email protected]

Mateus Crêspo,17,[email protected]

Perceba que a primeira linha do arquivo apenas indica quais são os significados dos dados que estão organizados
nele (chamamos esses significados de “campos” ou “colunas”) – portanto, a primeira linha deve conter os “nomes
dos campos”, ou “rótulos dos campos”. Cada linha, a partir da segunda, é o que chamamos de “registro”, um
conjunto único de dados em todos os campos.

Não esqueça: um arquivo do tipo CSV é um arquivo de texto simples! Ele pode ser completamente digitado em
um editor de textos simples, como o Bloco de Notas do Windows. Sua principal característica é a organização
dos dados em seu conteúdo. O arquivo CSV “impõe” uma certa estrutura para os dados contidos nele.

O arquivo CSV mostrado no exemplo acima seria o equivalente a uma tabela assim:

Nome Idade Email

Joao Gomes 48 [email protected]

Ana Senna 49 [email protected]

Pedro Carvalho 21 [email protected]

Mateus Crêspo 17 [email protected]

O Python consegue ler um arquivo CSV e interpretá-lo como uma tabela, permitindo diversas operações com
seus dados que não são possíveis em um arquivo de texto comum.

41.2. O Módulo csv e Suas Funções

A primeira coisa que você precisa ter em mente, para usar arquivos CSV, é que você importe o módulo csv, ou,
pelo menos, alguma função deste módulo.

import csv

ou

from csv import <alguém>

A primeira que vamos usar é a função DictReader(), assim mesmo, com “D” e “R” maiúsculas.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 150

 from csv import DictReader # Importei só a função DictReader

with open('clientes.csv', newline='', encoding='utf-8') as clientes:

# Na linha acima, criei a conexão clientes, que aponta para o arquivo clientes.csv

objeto = DictReader(clientes) # Criou-se um objeto do tipo DictReader

lista = list(objeto) # Criei uma lista a partir do objeto

print(lista)

Quando usamos a função DictReader(), o Python lê o arquivo CSV e cria um objeto especial (de um tipo especial
chamado DictReader), que é, na verdade, uma coleção de dicionários. Cada registro (linha) do arquivo CSV virará
um dicionário (a primeira linha não é considerada um registro, mas traz os nomes dos campos) e este “conjunto
de dicionários” pode ser convertido em uma lista, por exemplo, como no caso da penúltima linha do código acima.

Ao imprimir a lista, o resultado é este:

[{'Nome': 'Joao Gomes', 'Idade': '48', 'Email': '[email protected]'}, {'Nome': 'Ana

Senna', 'Idade': '49', 'Email': '[email protected]'}, {'Nome': 'Pedro Carvalho', 'Idade':
'21', 'Email': '[email protected]'}, {'Nome': 'Mateus Crêspo', 'Idade': '17', 'Email':
'[email protected]'}]

Veja que se trata de uma lista que contém 4 elementos (4 dicionários). Cada dicionário é composto por 3 entradas
(chave:valor) e as chaves dessas entradas são, justamente, os rótulos dos campos (‘Nome’, ‘Idade’ e ‘Email’).

Para enxergar melhor esta lista de dicionários, vou apresentar de um jeito “mais bonitinho”:

[{'Nome': 'Joao Gomes', 'Idade': '48', 'Email': '[email protected]'},

{'Nome': 'Ana Senna', 'Idade': '49', 'Email': '[email protected]'},

{'Nome': 'Pedro Carvalho', 'Idade': '21', 'Email': '[email protected]'},

{'Nome': 'Mateus Crêspo', 'Idade': '17', 'Email': '[email protected]'}]

Viu? É uma única lista contendo 4 dicionários (agora, todos coloridos para identificarmos mais facilmente).

Também podemos usar o laço for para ler linha a linha do objeto DictReader e poder manipulá-las. Por exemplo,
se eu quiser fazer apenas uma listagem contendo os E-mails dos usuários deste CSV, posso fazer assim:

from csv import DictReader # Importei só a função DictReader

emails = [] # Criei uma lista emails vazia

with open('clientes.csv', newline='', encoding="utf-8") as clientes:

# Criei o objeto clientes, a partir da conexão com o arquivo clientes.csv

listagem = DictReader(clientes) # Criou-se um objeto listagem (tipo DictReader)

for r in listagem: # Laço for vai iterar cada linha do objeto listagem

emails.append(r["Email"]) # Adiciona à lista emails o valor da chave Email

print(r["Email"]) # Imprime cada email, um em cada linha

print(emails) # Imprime a lista emails inteira

Todas as vezes que usamos r[“Email”], estamos pedindo o valor associado à chave “Email” dentro do objeto r. Já
r, por sua vez, é a variável que está iterando no laço for. A variável r contém apenas uma linha do objeto listagem.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 151

O resultado do programa acima será cada e-mail sendo listado em uma linha diferente e, ao final, a lista inteira
de e-mails de uma só vez.

[email protected]

[email protected]

[email protected]

[email protected]

['[email protected]','[email protected]','[email protected]','[email protected]']

João, tem um argumento na

função open que é newline=''. Para
que ele serve? Ele é obrigatório?

Ufa, que bom! Pensei que você não iria perguntar! O argumento newline='' serve para evitar que o Python confunda
as quebras de linha (\n) presentes em nossos dados com a quebra de linha que finaliza cada linha do arquivo
CSV. É claro que isso é uma precaução e só terá sentido, mesmo, se um dos nossos dados contiver o caractere
de escape \n. (o que não é o caso no arquivo usado nos exemplos até aqui).

41.3. E se o CSV tiver Outro Separador (Não a Vírgula)

Muitos arquivos são chamados de CSV (Valores separados por Vírgulas), mas não são separados por vírgulas,
mas por outros caracteres, como ponto-e-vírgula (;), hash (#), arroba (@) etc... como fazer? Bom, vamos a um
exemplo bem aqui, o arquivo clientes2.csv:

Nome;Endereco;Fone

Donna Carvalho;126 Orr Corner Suite 857\nEast Michael, LA 54411;906-918-6560

Aaron Leão;6965 Miller Station Suite 485\nNorth Michelle, KS 64364;815.039.3661x42816

Jennifer Gouveia;8749 Alicia Vista Apt. 288\nLake Victoriaberg, TN 51094;397-796-4842x451

Joshua Pereira;20116 Stephanie Stravenue\nWhitneytown, IA 87358;(380)074-6173

Andrea Gomes;558 Melissa Keys Apt. 588\nNorth Teresahaven, WA 63411;+57(8)7795396386

Victor Vieira;725 Gloria Views Suite 628\nEast Scott, IN 38095;768.708.3411x954

Perceba algumas coisas importantes sobre este arquivo:

[A] Os valores estão separados pelo caractere ponto-e-vírgula(;);

[B] Existem vírgulas dentro dos dados, nos endereços;

[C] Existem quebras de linha (\n) dentro dos endereços também (provavelmente erro de importação/criação
do arquivo CSV, mas existem). Ahhh, você vai enfrentar muito disso durante a sua vida de programador.

O erro presente na letra [C] a gente corrige (evita problemas) com o argumento newline='' dentro da função
open(), que eu já mencionei antes. Note que depois do newline=, tem que ter dois apóstrofos seguidos (abrir e
fechar apóstrofo, um logo seguido do outro).

O problema da letra [A] pode ser resolvido facilmente, por meio do argumento delimiter=';' dentro da função
DictReader(). O argumento delimiter te permite indicar qual é o caractere separador do CSV.

Vamos testar um código que acessa o arquivo mostrado acima:

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 152

 from csv import DictReader # Importei só a função DictReader

with open('clientes2.csv', newline='', encoding="utf-8") as clientes:

listagem = DictReader(clientes, delimiter=';') # Defini separador ;

for r in listagem:

print(r["Endereco"]) # Imprimir apenas os valores da chave Endereco

O resultado deste código irá gerar várias linhas, uma com cada um dos endereços do CSV original. Assim:

126 Orr Corner Suite 857\nEast Michael, LA 54411

6965 Miller Station Suite 485\nNorth Michelle, KS 64364

8749 Alicia Vista Apt. 288\nLake Victoriaberg, TN 51094

20116 Stephanie Stravenue\nWhitneytown, IA 87358

558 Melissa Keys Apt. 588\nNorth Teresahaven, WA 63411

725 Gloria Views Suite 628\nEast Scott, IN 38095

Podemos usar, claro, antes de imprimir esses valores, o método .replace() na string de cada endereço para
substituir o \n por uma vírgula, por exemplo (admita, ficou feito desse jeito).

41.4. Escrevendo Dados em um Arquivo CSV

Já que temos a capacidade de ler arquivos CSV, é óbvio que também temos a capacidade de criar e modificar
arquivos CSV existentes. Para fazer isso, partimos de uma lista de dicionários em nosso código para escrever
seus dados no arquivo CSV.

import csv # Apenas usei o "import" sem o "from"

usuarios = [{'Nome':'Joao','Login':'joaog','Admin': True},

{'Nome':'Ana','Login':'anac','Admin': False},
{'Nome':'Pedro','Login':'Pedroa','Admin': False},
{'Nome':'Mateus','Login':'mateush','Admin': True}]

with open('users.csv', 'w', encoding='utf-8') as saida_usuarios:

campos = ['Nome', 'Login', 'Admin'] # Definindo os rótulos dos campos

escrever_saida = csv.DictWriter(saida_usuarios, fieldnames=campos)

escrever_saida.writeheader() # Este método escreve o cabeçalho (campos)

for elemento in usuarios:

escrever_saida.writerow(elemento) # Este método escreve um registro por vez

Explicando o código acima:

[A] Na primeira linha, importei o módulo csv usando apenas o import, ou seja, sempre que eu for me referir
a funções ou variáveis existes lá, deverei usar “csv.” como prefixo;

[B] Perceba que usuarios é uma lista de dicionários. É esse formato de dados que usamos para escrever em
um arquivo CSV.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 153

 [C] Perceba que na função open, usamos o caractere ‘w’ como parâmetro para dizer que vamos escrever e
chamamos a conexão como arquivo users.csv de saida_usuarios.

[D] Criamos uma lista chamada campos, contendo os rótulos dos campos, indicados a partir das chaves das
entradas dos dicionários existentes lá na lista usuarios.

[E] Usamos a função DictWriter() para criar um objeto chamado escrever_saida. A função DictWriter() pede
dois argumentos: [1] o nome da conexão com o arquivo CSV (no caso “saida_usuarios”) e [2] os rótulos
dos campos, por meio da expressão fieldnames=campos.

[F] O método .writeheader() escreve UMA ÚNICA VEZ, o cabeçalho (header) do arquivo CSV. Já se sabe qual
é o cabeçalho porque a gente o indicou na cláusula fieldnames=campos.

[G] O método .writerow(lista_ou_dicionario) escreve o conteúdo do argumento lista_ou_dicionario em uma

das linhas de dados do arquivo CSV. Como o laço for está iterando item dentro da lista usuarios, cada
iteração vai gravar uma linha diferente no arquivo CSV, usando os dados presentes em item, que é um
dicionário, porque está varrendo, posição a posição, a lista usuarios.

Não esqueça: se nós usamos as classes DictReader() e DictWriter(), estamos convertendo os dados de um CSV
em dicionários e vice-versa! Portanto, o método .writerow(item) requer que o parâmetro item seja um dicionário.

O arquivo users.csv fica assim, ao terminar de executar o código acima:

Nome,Login,Admin

Joao,joaog,True

Ana,anac,False

Pedro,Pedroa,False

Mateus,mateush,True

João, não tem um jeito mais prático e simples de

trabalhar com arquivos CSV? Tem que ser por meio
de dicionários mesmo? Achei tão complicado!

Tem sim, meu caro amigo! Não é obrigatório trabalharmos com dicionários, não!

41.5. Usando Listas em vez de Dicionários

Também podemos interagir com arquivos CSV sem usar dicionários: usando apenas listas, por exemplo! A gente
só precisa trocar a função DictReader(), que lê cada linha do CSV e a transforma em um dicionário, pela função
reader(), que lê cada linha do csv e a transforma em uma lista.

from csv import reader as rd # Importei reader do módulo csv com o apelido rd

usuarios = [] # Criei uma lista vazia, chamada usuarios

with open('users.csv', encoding='utf-8') as users: # Conexão users com ‘users.csv’

usuarios = list(rd(users)) # A lista usuarios ganha o resultado de rd(users)

print(usuarios)

Note que eu pedi para ler a conexão users com a função rd() (que é csv.reader()) e já transformei seu resultado
em formato lista (com a função list()), armazenando dentro da variável usuarios. Esse objeto (usuarios), que
sempre foi uma lista (lá em cima foi declarada vazia), passou a ter o conteúdo resultante do csv.reader().

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 154

O objeto que será impresso na tela (usuarios) é uma lista de listas, olha só:

[['Nome', 'Login', 'Admin'], [], ['Joao', 'joaog', 'True'], [], ['Ana', 'anac', 'False'],
[], ['Pedro', 'Pedroa', 'False'], [], ['Mateus', 'mateush', 'True'], []]

Perceba a presença de alguns [ ] (listas vazias) depois de cada linha do arquivo CSV. Essas listas vazias são os
\n (quebras de linha) ao fim de cada linha do arquivo CSV. (convertendo para dicionário, não dá esse problema,
mas convertendo para lista, ele acontece).

Você pode corrigir isso com um código que faz o append() deste item a uma segunda lista somente se este item
for diferente de [ ]. É uma sugestão, apenas:

from csv import reader as rd

usuarios = []

usuarios2 = []

with open('users.csv', encoding='utf-8') as users:

usuarios = list(rd(users))

for item in usuarios: # Varre (itera) usuarios, item a item.

if item != []: # Testa se item (iteração atual) é diferente de []

usuarios2.append(item) # Se for, adiciona à lista usuarios2

print(usuarios2)

O resultado deste código é uma lista de listas sem os itens [ ] do resultado anterior.

[['Nome', 'Login', 'Admin'], ['Joao', 'joaog', 'True'], ['Ana', 'anac', 'False'],

['Pedro', 'Pedroa', 'False'], ['Mateus', 'mateush', 'True']]

Agora, para escrever em um arquivo CSV, podemos usar a função writerows() em vez da função DictWriter(), se
o objeto original for uma lista de listas.

from csv import writer as wt

usuarios = [['Nome', 'Login', 'Admin'], ['Liborio', 'libcat', True], ['Amora',

'amoradog', False], ['Rogerio', 'rogerduck', False], ['Inacio', 'luissnake', True]]

with open('users.csv','w', newline='', encoding='utf-8') as arquivo:

escritor = wt(arquivo)

escritor.writerows(usuarios)

No código acima, a lista usuarios é uma lista de listas (cada elemento da lista usuarios é uma lista com três
elementos). Abrimos a conexão com o arquivo users.csv com o parâmetro 'w', para poder escrever nele (gravar
dados nele). Usamos a cláusula newline='' para evitar que ele crie linhas em branco adicionais e usamos o
encoding='utf-8' para que ele possa entender caracteres acentuados. Chamamos esta conexão de arquivo.

Criamos um objeto chamado escritor que aplicará o ato de escrever (apelido wt da função writer()) à conexão
arquivo. Depois, usamos o método .writerrows() no objeto escritor, tendo como dados o que está na lista
usuarios.

O método .writerows() escreve todas as linhas de um arquivo CSV de uma só vez, a partir de uma lista de listas
ou de uma lista de tuplas. Cada elemento da lista principal será uma linha do arquivo CSV, cada elemento das
listas/tuplas internas será um dado em uma coluna do CSV.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 155

Desta forma, a lista...

usuarios = [['Nome', 'Login', 'Admin'], ['Liborio', 'libcat', True], ['Amora',

'amoradog', False], ['Rogerio', 'rogerduck', False], ['Inacio', 'luissnake', True]]

será escrita, no arquivo CSV, como:

Nome,Login,Admin

Liborio,libcat,True

Amora,amoradog,False

Rogerio,rogerduck,False

Inacio,luissnake,True

É bem mais fácil trabalhar com listas de listas (ou listas de tuplas) do que com dicionários, não é mesmo? Os
arquivos CSV nos dão esta facilidade: usar listas ao invés de dicionários.

41.6. Modificando o Conteúdo de um Arquivo CSV

João, eu percebi que posso abrir uma conexão para ler um arquivo CSV e
para escrever (com o ‘w’) em um arquivo CSV. Mas eu posso usar a opção ‘a’
para alterar um arquivo CSV sem ter que reescrevê-lo totalmente?!

Excelente pergunta, amigo leitor! Ela tem exatamente “duas formas de resposta”... Presta atenção...

Vamos imaginar que você queira alterar o nome de um usuário dentro do arquivo CSV. Por exemplo, lá em cima,
no arquivo usado como exemplo, se eu desejar alterar o nome do usuário de ‘Joao’ para ‘João Antonio’... eu consigo
fazer isso diretamente? Não. Não consigo.

Os arquivos CSV são sequenciais: eles devem ser gravados em uma única sequência, byte por byte, letra por
letra... não dá para alterar o arquivo CSV diretamente lá dentro e “só trocar aquele específico dado no meio dele”,
usando a opção ‘a’... (na verdade, a opção ‘a’ ela apenas permite append, ou seja, adicionar dados no final do
arquivo, seja ele de texto normal ou texto CSV).

A solução é bem “chata”: [A] Você tem que abrir o arquivo CSV, trazendo seus dados para dentro do código Python
(como lista de dicionários ou lista de listas/tuplas – você decide); [B] Você faz a alteração no dado desejado dentro
do seu programa; [C] Você escreve a lista dentro do arquivo novamente, usando o open() com a opção 'w' (isso
reescreverá a lista inteira dentro do arquivo, substituindo o conteúdo anterior do CSV pelo atual).

Ou seja, qualquer pequena alteração no conteúdo de um arquivo, no meio dele, exige que abramos o arquivo,
modifiquemos o dado desejado e depois reescrevamos completamente o arquivo.

Porém, é possível alterar apenas uma parte do arquivo sem reescrever ele todo: se esta alteração for uma
inclusão de dados no final do arquivo. Para isso, usamos a opção 'a' dentro da função open().

Não dá para alterar dados no meio do arquivo CSV, só dá para adicionar uma nova linha no final do arquivo.

41.7. Resumindo o Trabalho com CSV

Importante em Todos os Casos do CSV

Você sempre terá que importar o módulo csv ou, pelo menos, alguma função deste módulo!

Usando Lista de Dicionários

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 156

Se você quer usar uma lista contendo dicionários dentro (uma opção necessária, às vezes), use:

DictReader() para criar um objeto do tipo DictReader que poderá ser convertido em uma lista de dicionários.
Esta função lê o arquivo CSV e traz seus dados para dentro do programa. O objeto do tipo DictReader tem que ser
convertido em uma lista com a função list().

DictWriter() para criar um objeto do tipo DictWriter, que poderá ler uma lista de dicionários e converter cada
elemento desta lista em uma linha do arquivo CSV. Esta função escreve no arquivo CSV. Em objetos deste tipo,
podemos usar três métodos:

- .writeheader() para escrever o cabeçalho do arquivo CSV (os rótulos dos campos, que ficam na primeira
linha do arquivo) a partir dos nomes das chaves presentes nos dicionários dentro da lista principal. O
parâmetro deste método é um iterável (lista ou tupla).

- .writerow() para escrever cada registro (linha de dados) do arquivo CSV, a partir dos valores que estão
presentes nos dicionários dentro da lista principal. (precisará de um laço for para iterar a lista principal
à procura de cada dicionário, em cada elemento da lista). O parâmetro deste método tem que ser um
dicionário.

- .writerows() para escrever todos os registros (linhas de dados) de uma vez só no arquivo CSV, a partir
dos valores que estão presentes nos dicionários dentro da lista principal (não preciso iterar nada!). O
parâmetro deste método tem que ser uma lista de dicionários.

Todos os três métodos mostrados acima devem ser usados em um objeto do tipo DictWriter, criado pela função
DictWriter(). Ou seja, esses métodos devem ser usados em objeto.writeheader(), por exemplo, somente se o
objeto foi criado pela DictWriter().

Usando Lista de Listas ou Lista de Tuplas

Se você quer usar uma lista contendo listas/tuplas dentro, use:

reader() para criar um objeto do tipo _csv.reader que poderá ser transformado em uma lista de listas ou em uma
lista de tuplas. Esta função lê o arquivo CSV e traz seus dados para dentro do programa. O objeto do tipo -
csv.reader tem que ser convertido em uma lista com a função list().

writer() para criar um objeto do tipo _csv.writer, que poderá ler uma lista de listas/tupas e converter cada
elemento desta lista em uma linha do arquivo CSV. Esta função escreve no arquivo CSV. Em objetos deste tipo,
podemos usar dois métodos:

- .writerow() para escrever cada registro (linha de dados) do arquivo CSV, a partir dos valores que estão
presentes nos iteráveis internos (listas ou tuplas) dentro da lista principal. (precisará de um laço for para
iterar a lista principal à procura de cada lista/tupla interna, em cada elemento da lista). O parâmetro deste
método tem que ser uma lista ou tupla

- .writerows() para escrever todos os registros (linhas de dados) de uma vez só no arquivo CSV, a partir
dos elementos que estão presentes nas listas/tuplas dentro da lista principal (não preciso iterar nada!). O
parâmetro deste método tem que ser uma lista de lista/tuplas.

Alterando o Conteúdo de um Arquivo CSV

Para inserir novos dados (novas linhas) no final de um arquivo CSV, basta usar a função open() contendo a opção
'a' (de “append”, ou “adicionar”) – para este procedimento, não é necessário abrir o arquivo para reescrevê-lo por
completo. Para alterar um dado qualquer no meio do conteúdo de um arquivo CSV, a gente precisa abri-lo (com
o open()), modificar o dado dentro do código (dentro da lista que tá lá dentro); e, depois, escrever a lista modificada
no arquivo, usando a opção 'w' na função open().

Em resumo, ou a gente adiciona novos dados no final do arquivo, ou a gente tem que ler, alterar dentro do código
e reescrever o arquivo todo de uma vez.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 157

41.8. Vamos exercitar? O Bicho vai Pegar!

Crie um programa que apresente a seguinte tela inicial: Um menu contendo “Cadastrar
Usuário”, “Salvar Usuários”, “Listar Usuários”, “Mostrar Dados do Usuário”, “Apagar Usuário” e
“Fechar”.
Os dados a serem armazenados sobre cada usuário são: Nome, Idade, Telefone e E-mail (pode
guardar todos em string). A opção Salvar Usuários vai escrever a lista deles em um arquivo
CSV. A opção Listar Usuários vai mostrar na tela a listagem de todos eles, de forma
TABULADA (como uma tabela). A opção “Mostrar Usuário” vai apresentar na tela apenas O
USUÁRIO escolhido (pesquisado) por você de forma TABULADA também (organizada como
uma tabela).
A opção Apagar Usuário vai pesquisar um nome de usuário e dizer se ele existe ou não,
depois, vai pedir, caso ele exista, para confirmar o apagamento. Depois de confirmar que quer
apagar, o usuário será retirado do arquivo CSV (você reescreverá o arquivo CSV sem este
usuário).
O programa só para de rodar se o usuário escolher a opção Fechar.

“Só isso”, João? Não quer também

que eu faça um sanduíche de atum
e um suco de maracujá, não, fíu?

Eu sei que você consegue, amigo leitor! Mãos à obra!

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 158

42. Trabalhando com Arquivos JSON
42.1. O que é JSON?
JSON significa JavaScript Object Notation (ou “Notação para Objetos em JavaScript”). JavaScript, em si, é uma
linguagem de programação muito usada na Internet, para construir sites e aplicações Web.

JSON é um formato de arquivo para trocar dados, assim como o CSV, e é muito popular na Internet. Os arquivos
JSON também são textos simples, podendo ser abertos e modificados diretamente em qualquer editor de textos,
como o Bloco de Notas do Windows.

Como nós já vimos muito rapidamente em uma lição anterior, o JSON tem um formato muito similar aos
dicionários do Python, o que torna esta estrutura de dados ideal para trabalhar com esse formato de arquivo.
Aqui embaixo, um pequeno exemplo de um arquivo JSON simples, o arquivo notafiscal.json:

"comprador": "liboriocat",

"quantidade": "6",

"produto": "caderno 200 folhas"

Vamos usar este arquivo para dar exemplo de como ler um arquivo JSON, trazendo seus dados para o nosso
código.

42.2. Lendo um arquivo JSON

No nosso código, devemos, primeiramente, importar o módulo json, porque é ele que contém as funções e classes
usadas para manipular arquivos JSON. Veja o código a seguir:

import json # Importei o módulo inteiro, sem especificar

with open('notafiscal.json') as json_interno: # Criei a conexão json_interno

dicionario = json.load(json_interno) # Criei um dicionário com a função load()

print(dicionario) # Mandei imprimir o dicionário diretamente

Veja só... sem frescura... sem conversões... apenas usei a função load() do módulo json para criar um dicionário
chamado dicionario – depois, é só usar ele diretamente no código. O resultado do código acima será:

{'comprador': 'liboriocat', 'quantidade': '6', 'produto': 'caderno 200 folhas'}

42.3. Escrevendo um arquivo JSON

Primeiramente, precisaremos ter um dicionário em nosso código para poder escrever estes dados em um arquivo
JSON. Que tal este aqui? (um dicionário chamado dados):

dados = {'Aluno': 'João', 'Turma': '9º A', 'Nota1': '10.0', 'Nota2': '8.4'}

import json # Importei todo o módulo json

with open('output.json', 'w') as json_escrita: # Abri conexão com ‘w’ para escrever

json.dump(dados, json_escrita) # Escrevi o dicionário dados na conexão

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 159

No código anterior, começamos com um dicionário chamado dados, que contém 4 informações acerca de um
aluno (quatro entradas do tipo chave:valor). Abrimos uma conexão com um arquivo chamado output.json no
modo w (para escrever) e chamamos a conexão de json_escrita.

Por fim, usamos a função dump() para escrever o conteúdo do dicionário dados na conexão json_escrita.

Se você for abrir o arquivo output.json, ele apresentará o seguinte conteúdo:

{"Aluno": "Jo\u00e3o", "Turma": "9\u00ba A", "Nota1": "10.0", "Nota2": "8.4"}

É, os caracteres ã em João e º em 9º ficaram estranhos... esqueci de colocar o encoding no open(). Se corrigirmos

a linha para...

with open('output.json', 'w', encoding=’utf-8’) as json_escrita:

Além disso, tenho que adicionar o parâmetro ensure_ascii=False na função dump(), como se vê no exemplo
abaixo:

json.dump(dados, json_escrita, ensure_ascii=False)

Isso gerará o arquivo JSON com os verdadeiros caracteres especiais que constam em nosso código.

{"Aluno": "João", "Turma": "9º A", "Nota1": "10.0", "Nota2": "8.4"}

42.4. Arquivos JSON com Mais de Um Registro

Nos exemplos acima, os arquivos JSON só continham um registro cada um. Ou seja, nos códigos anteriores,
conseguimos armazenar, apenas, o conteúdo de um dicionário em cada arquivo JSON. Porém, é possível, sim, ter
mais de um registro em um único arquivo JSON... o arquivo que contém mais de um registro é assim:

[ {"id":1,"nome":"João","idade":25,"cidade":"São Paulo"},
{"id":2,"nome":"Maria","idade":30,"cidade":"Rio de Janeiro"},
{"id":3,"nome":"Carlos","idade":22,"cidade":"Belo Horizonte"} ]

Este arquivo se chama multiplo.json e vamos usá-lo daqui pra frente. Percebeu com o que se parece este
conteúdo?

Isso parece com uma

grande lista contendo
dicionários, não é?

Exatamente, caro leitor! Um arquivo JSON pode ter vários registros, sendo cada um deles um dicionário (as
chaves abrindo e fechando determinam isso) dentro de uma grande lista (os colchetes no início e no final do
arquivo definem isso).

Lendo e Escrevendo Arquivos JSON com Vários Registros

Podemos tratar os arquivos JSON que têm vários registros do mesmo jeito como tratamos os arquivos JSON
simples: usando as funções load() e dump(). Eles conseguem entender os dois tipos de arquivos JSON e já
conseguem construir/ler os objetos internos a partir deles.

import json # Importei todo o módulo json

with open('multiplo.json') as json_lido: # Abri conexão para ler como json_lido

lista = json.load(json_lido) # Guardei o conteúdo de json_lido na lista

print(lista)

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 160

Note que usei, da mesma forma que havia usado antes, a função load() do módulo json para carregar o conteúdo
do arquivo multiplo.json para dentro do objeto lista. Ele se torna uma lista de dicionários.

O resultado de imprimir o objeto lista é esse:

[{'id': 1, 'nome': 'João', 'idade': 25, 'cidade': 'São Paulo'}, {'id': 2, 'nome':
'Maria', 'idade': 30, 'cidade': 'Rio de Janeiro'}, {'id': 3, 'nome': 'Carlos', 'idade':
22, 'cidade': 'Belo Horizonte'}]

Em vez de usar print(lista), eu posso pedir para printar apenas um dos itens da lista, como, por exemplo:

print(lista[1]['idade'])

Essa linha vai imprimir (na tela) o valor associado à chave idade que está no elemento 1 da lista principal. Ou
seja, a idade da usuária Maria. O resultado será, portanto,

30

Para escrever em arquivos JSON de vários registros, usamos a mesma função dump(), com a diferença de que
usaremos a partir de uma lista de dicionários, em vez de usá-la a partir de um único dicionário.

import json

dados = [{'id': 1, 'nome': 'Ana', 'idade': 28, 'estado': 'Pernambuco'}, {'id': 2,

'nome': 'Mateus', 'idade': 29, 'estado': 'Rio de Janeiro'}, {'id': 3, 'nome':
'Mariana', 'idade': 22, 'estado': 'Paraíba'}] # dados é uma lista de dicionários

with open('multiplo.json','w', encoding='utf-8') as json_escrito:

json.dump(dados,json_escrito,ensure_ascii=False)

42.5. É Possível Alterar um Arquivo JSON? (Adicionar ou Retirar Registros)

Vimos que é possível adicionar dados no final de um arquivo de texto simples e também de um arquivo CSV.
Basta, para isso, que usemos a opção 'a' nos parâmetros da função open().

Porém, não podemos usar a opção 'a' com arquivos JSON de múltiplos registros. A razão é simples: sempre que
usamos a função open() com a opção , o conteúdo que estamos colocando será incluído no final do arquivo, depois
do último caractere que já estiver lá.

Ora, o último caractere de um arquivo JSON com múltiplos registros é ] (fechamento de colchetes). Escrever
qualquer coisa depois dele torna o arquivo JSON corrompido, mal escrito, com formato errado.

A única forma que temos, portanto, de adicionar dados no final de um arquivo JSON múltiplo ou modificar qualquer
dado lá existente é: [A] ler o conteúdo do arquivo para dentro de uma lista de dicionários no código; [B] realizar
as alterações desejadas no conteúdo desta lista no nosso código; [C] realizar o .dump() desta lista para dentro do
arquivo, substituindo seu conteúdo.

Agora me bateu uma preocupação... se o arquivo JSON for muito grande? (tipo: se ele tiver
uns 2000 registros)... vai precisar ele ser aberto inteiro, mesmo que eu só queira adicionar
ou modificar um deles? Isso seria um baita desperdício de tempo e memória, não?

Exato, amigo leitor! Se um arquivo JSON for muito grande, leva muito tempo para abri-lo e para escrevê-lo. Isso
é particularmente “indesejável” se a quantidade de alterações / inclusões for pequena... Seria realmente bem
estranho abrir um arquivo com mais de duas mil linhas só para alterar uma pequena letra.

A solução para isso foi pensada pelo mesmo pessoal que criou o formato JSON: é o formato JSONL (JSON Lines,
ou, traduzindo, JSON Linhas). Este formato de armazenamento de dados é mais “versátil” que o formato JSON
original, especialmente para múltiplos registros.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 161

42.6. O Formato de Arquivo JSONL
Um arquivo JSONL é formado por vários registros (semelhantes a dicionários, como o JSON), mas o início e o
final do arquivo não possuem os colchetes. Abaixo, um exemplo do arquivo alunos.jsonl:

{"id":1,"nome":"Alice","idade":25}

{"id":2,"nome":"Bob","idade":30}

{"id":3,"nome":"Carol","idade":22}

Outra diferença do JSONL para o JSON além dos colchetes é que este último separa os registros por quebras de
linha (\n), enquanto o formato JSON os separa por vírgula. Por isso, o formato JSONL pode ser chamado, também,
de NDJSON, ou Newline Delimited JSON (JSON Delimitado por uma Nova Linha).

A vantagem do JSONL é que dá para adicionar facilmente linhas abaixo do arquivo por meio da opção 'a' da função
open(), já que não há ] no final do arquivo. Isso nos dá a facilidade de não precisar abrir o arquivo inteiro toda vez!

Por causa disso, o formato JSONL é usado em ambientes onde há arquivos muito grandes e que recebem muitos
dados várias vezes.

Abrindo (Lendo) um Arquivo JSONL

Aqui abaixo, um código para abrir o conteúdo de um arquivo JSONL.

import json

with open("alunos.jsonl", "r", encoding="utf-8") as f:

for line in f: # Lendo linha por linha

objeto = json.loads(line) # Convertendo a string JSON em dict com loads()

print(objeto) # Imprimir na tela o dicionário objeto

Note que, neste código, foi escrita a opção "r" na função open() – ela é opcional para indicar que você quer ler
um arquivo (trazer os dados de um arquivo para dentro do seu código). Até este exemplo, eu não havia usado nem
uma única vez, né? Outra coisa: usamos uma laço for para varrer (iterar) todos os itens em f. (f é o nome do
objeto que foi criado pela leitura do arquivo alunos.jsonl) porque o método loads() carrega o conteúdo de apenas
uma linha (um dicionário apenas) – por isso, o objeto objeto é um dicionário.

Ô, João, o arquivo JSONL tem que

ter, necessariamente, a extensão
.jsonl, como no exemplo alunos.jsonl?

Não necessariamente, caro leitor! Um arquivo JSONL pode ter a extensão .jsonl, ou .ndjson, pode ter
extensão .txt, pode ter até extensão .log (usada para registrar os dados de histórico de funcionamento de
sistemas, por exemplo). Só peço que você evite usar a extensão .json no nome de um arquivo que tem formato
JSONL... isso pode confundir os programas que vê lê-lo (eles podem pensar que se trata de um arquivo JSON
tradicional).

Lembrete: a função .load() é usada apenas em arquivos JSON tradicionais, porque ela aguarda dados na forma
de uma lista de dicionários. A função .loads() é quem deve ser usada em arquivos JSONL (e também consegue
ser usada em arquivos JSON tradicionais), para ler esses arquivos linha a linha.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 162

Para adicionar uma Linha ao Arquivo JSONL

Se quisermos escrever um dado a mais (um dicionário a mais) a um arquivo JSONL, podemos fazer uso da
função .dumps(), em vez da .dump(), que é usada para JSON tradicional.

import json

dados = [{"nome": "Alice"}, {"nome": "Bob"}]

with open("dados.jsonl", "w", encoding="utf-8") as f:

for obj in dados:

f.write(json.dumps(obj) + "\n") # Escreve cada objeto JSON em uma linha

Perceba que usamos o laço for para iterar, elemento por elemento, a lista dados. Cada elemento desta lista é um
dicionário. Ao usar a função .dumps(), o Python converte o objeto obj, que é o iterável dicionário da lista dados,
em uma string JSON que, somada à quebra de linha (\n) será escrita no final do arquivo por meio da função
write().

42.7. Resumindo Arquivos JSON e JSONL

Formato dos Arquivos JSON

Os arquivos JSON são formados por UM REGISTRO (cujo formato é semelhante a um dicionário do Python) ou por
VÁRIOS REGISTROS (cada registro é similar a um dicionário do Python e todos eles juntos estão em uma única
lista que envolve o arquivo JSON inteiro).

Funções para Arquivos JSON

Usamos duas funções, do módulo json, para arquivos JSON:

load() para atribuir a uma variável o conteúdo de um arquivo JSON obtido pela função open(). O objeto (variável)
criado pelo load() pode ser...

...um dicionário, se o arquivo JSON for composto por um único registro.

... uma lista de dicionários, se o arquivo JSON que foi lido for composto por vários registros.

Sempre usamos a função load() assim: nome_do_objeto = json.load(nome_da_conexão).

dump() para gravar no arquivo JSON o conteúdo de um objeto. Se o objeto for...

...um dicionário, o arquivo JSON será preenchido por apenas um único registro.

... uma lista de dicionários, arquivo JSON será preenchido por vários registros.

Sempre usamos a função dump() assim: json.dump(nome_do_objeto, nome_da_conexão, outras_opções).

Uma das opções que quase sempre usamos (é preferível que você use) na função dump() é a opção
ensure_ascii=False, que garante que os caracteres especiais, como símbolos e letras acentuadas sejam
registrados corretamente dentro do arquivo JSON (caso não incluamos a opção, o arquivo JSON vai registrar
dentro dele o código Unicode do caractere estranho).

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 163

43. O Anaconda: o Python “Turbinado” para Ciência de Dados
43.1. O que é o Anaconda?
Não sei se você sabe, mas “Python” (o nome da linguagem) é o nome de uma gama de espécies de cobras ao
redor do mundo (nós naturalmente as chamamos de Píton ou Pitón). Elas não são cobras venenosas, são
constritoras (aquele tipo de cobra grande que mata as vítimas as “apertando” e destroçando seus corpos).

Anaconda é, apenas, um termo usado para designar cobras muito grandes, normalmente encontradas nos rios da
América do Sul, como na Amazônia.

Deixando a biologia de lado (João Antonio também é Cultura Geral) e voltando para a programação, Anaconda é
o nome dado a uma distribuição do Python que junta, além da própria linguagem Python, centenas de módulos,
arquivos, programas e recursos úteis para tornar a sua programação mais fácil!

O Anaconda é um “Python Turbinado” (e é completamente gratuito, assim como o próprio Python normal).

43.2. Baixando o Anaconda

Acesse o site https://www.anaconda.com/download para ter acesso ao sistema para o seu computador (Windows,
Linux ou Mac). Esta páginas é originalmente escrita em inglês. Caso não consiga entendê-la, solicite ao seu
navegador que a traduza

Página do Download do Anaconda, em

Março de 2025 após a tradução
automática do Mozilla Firefox..

Basta fornecer seu e-mail e clicar no botão Submeter.

O aviso do site de que foi enviada para o seu email uma mensagem
contendo o link para você baixar o Anaconda.

Consultando o meu e-mail indicado, recebo o link para baixar o Anaconda...

Basta clicar no botão Download Now (Baixar Agora) no conteúdo da mensagem de e-mail
que você receber... você será redirecionado para...

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 164

 ...a página de Downloads do Anaconda, onde poderá
escolher qual a versão do programa deseja.

Como eu uso Windows 11, escolherei a versão para

Windows, é claro!

O site já reconheceu isso (reconheceu que meu

computador usa Windows), por isso ele colocou o
botão verde (Download) já apontando para a versão
certa.

Tanto faz se eu clico em qualquer um desses dois

locais.

O Download iniciará e você só precisa esperar pelo final do processo. (o meu navegador sempre abre uma janela
perguntando onde e com que nome o arquivo será baixado no meu computador, mas nem todo faz isso).

Indicando Nome e Local para fazer o download do

arquivo de instalação do Anaconda.

Agora, é só aguardar o Download e partiremos para a Instalação do Anaconda.

43.3. Instalando o Anaconda

Encontre o arquivo instalador recém-baixado e execute-o (duplo clique nele).

O arquivo Anaconda3-2024.10-1-Windows..., que é o

arquivo instalador do sistema Anaconda. Aplique um
clique duplo nele para começar a instalação.

A partir deste ponto, é basicamente clicar várias vezes no botão Next>

(que quer dizer “Próximo>”) para avançar para os próximos passos do
processo de instalação.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 165

 Na próxima tela, a que mostra os Termos de Aceitação, é só clicar em I
Agree (Eu Concordo).

Agora, é só clicar Next> mais duas vezes.

Nesta última tela, antes do processo de instalação, marque os três itens

mostrados ao lado (só não marque aquele que acompanha a mensagem
NOT RECOMMENDED – Não Recomendado).

Depois, clique em Install (Instalar).

O procedimento de instalação acontecerá por poucos minutos (ou

muitos, dependendo da velocidade do seu computador).

Aqui, durou cerca de 3 minutos. Depois disso, é só clicar em mais um

Next>.

A próxima tela pergunta se você quer se inscrever na nuvem (Cloud) da

Anaconda, para poder aproveitar os recursos do Jupyter Notebook
direto na nuvem (para poder acessar de onde quiser).

Particularmente, isso é uma decisão pessoal, mas eu acho interessante.

Clique aqui, se desejar. Ou clique em Next> para seguir para a próxima

tela do instalador

Se você escolheu acessar a Cloud do Anaconda, uma página do site deles

abrirá em uma janela do navegador, apontando para a página ao lado.
Clique no botão Get Started > (que significa “começar”).

A página Plans and Pricing (Planos e Preços) vai ser aberta, e você
poderá escolher qual o melhor plano mensal para você.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 166

 Escolha a opção Free para ter acesso aos
recursos básicos da Cloud da Anaconda. Se
você deseja realmente ganhar dinheiro
desenvolvendo software, talvez seja
interessante pagar mensalmente por
outros planos...

(todos os valores estão em Dólar, ok?)

Complete a sua inscrição usando um e-

mail válido e pronto... depois poderá usar
as ferramentas online da Anaconda.

Voltando ao Instalador, é só clicar no Next> da última janela e esta tela

aqui será apresentada.

Eu costumo desmarcar as duas opções que o programa me oferece

nesta tela e, por fim, clico em Finish.

43.4. O que o Anaconda Contém? E Onde ele Está?

Depois de instalado, basta achar o ícone do Anaconda Navigator no seu sistema e clicar nele. A imagem a seguir
foi retirada do Windows 11, onde o meu Anaconda foi instalado.

Grupo Anaconda (anaconda3) no menu Iniciar do Windows 11 e, dentro dele...

O Anaconda Navigator, que nos ajudará a instalar novos pacotes, módulos e recursos,
se precisarmos.

O Jupyter Notebook, que pode ser usado durante treinamentos mais avançados, para
você fazer anotações e criar códigos ao mesmo tempo (é uma ferramenta muito
interessante para você fazer suas anotações enquanto aprende).

O Spyder, que é o IDE que você usará enquanto usa o Anaconda (pode esquecer o
IDLE do Python que estamos usando desde a primeira lição! Este aqui é muito
melhor!)

Cada ferramenta dentro do grupo Anaconda tem uma função específica e neste material não vamos nos ater com
detalhes a nenhuma delas, exceto ao Spyder (que passarei a ensinar e utilizar aqui) e o Jupyter Notebook, que
ensinarei a utilizar aqui para que você possa usá-lo quando estiver estudando em outros cursos mais avançados
da linguagem Python!

Anaconda Navigator

Este programa é a “central de comando” do Anaconda, permitindo instalar, desinstalar, atualizar e modificar os
componentes que vêm junto com o Anaconda.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 167

O programa se apresenta como um grande painel cheio de recursos, na forma de ícones separados, que podem
ser instalados (install) ou abertos (launch). Se o botão install aparecer, é porque aquele componente ainda não
está instalado em seu Anaconda. Se o botão launch estiver aparecendo, é porque aquele recurso já está instalado
e você pode usá-lo normalmente.

Janela do Anaconda Navigator

e seus vários componentes.

Alguns já estão instalados e já

podem ser usados (launch).

Alguns outros não estão

instalados e, se você quiser,
pode instalá-los (install).

Spyder

O Spyder é um IDE profissional para Python. Ele agrega, em uma só janela, o editor de código, o Shell (console
do Python) e outros recursos que aceleram bastante a programação.

Janela do Spyder e seus 3

painéis:

(a) O painel do editor do

código, onde efetivamente
nós vamos escrever nossos
códigos. (é o painel grande à
esquerda).

(b) O painel do console,

localizado embaixo à direita,
onde nós vemos o código que
escrevemos ser executado.

(c) O painel superior direito,

que muda de acordo com a
necessidade: agora, ele
mostra os valores das
variáveis do programa.

O Spyder é simplesmente MUITO MELHOR que o IDLE original do Python, porque nos ajuda na hora de escrever
os nossos códigos com vários recursos, sugestões, correções, análises e muito mais. Você vai aprender a amar
esses IDEs profissionais com o passar do tempo, eu garanto! (e o Spyder está em português!)

Jupyter Notebook

O Jupyter Notebook é um programa (que roda no seu navegador) para escrever documentos de texto (como uma
espécie de Word) que pode te ajudar a escrever as anotações das tuas aulas de Python (sejam as aulas do meu
curso online, sejam as aulas de outros professores, online ou não).

A grande vantagem do Jupyter Notebook é que, dentro dele, dá para escrever código Python e testá-lo quando
você está digitando as suas anotações! Sim! O Jupyter Notebook roda os programas como se fosse o Shell do
Python, ali mesmo, no mesmo ambiente em que você está digitando as suas anotações! É muito prático!

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 168

 O Jupyter Notebook rodando
em uma janela do navegador
web (no meu caso, o Mozilla
Firefox).

Por meio do Jupyter, a gente

consegue redigir anotações
e outros documentos com
códigos que podem ser
executados diretamente no
documento.

É rápido e muito prático, por

exemplo, escrever apostilas
e explicações sobre o Python
com o Jupyter Notebook.

Mas, João, eu preciso aprender e

utilizar todas essas ferramentas
que acompanham o Anaconda?

De jeito nenhum, amigo leitor! Você não precisa nem mesmo usar o Anaconda! Instalá-lo no seu computador é
algo completamente opcional! Há outras distribuições do Python e outros IDEs tão bons quando o Spyder!

O Jupyter Notebook quase não tem concorrentes, sinceramente, porque ele foi criado para uma função bem
específica, porém, você também o utiliza apenas se quiser! (eu, mesmo, não costumo usá-lo, nem mesmo quando
estou assistindo a cursos e me atualizando) ... prefiro escrever meus resumos e anotações com a boa e velha
caneta e papel (tá, pode me chamar de velho!).

Uma coisa é Importante: o Anaconda é uma distribuição Python muito completa para quem quer trabalhar com
ciência de dados, análise de dados e aprendizado de máquina. Todas as ferramentas que este programa traz
consigo são feitas para estas finalidades especialmente.

Nas próximas lições, abordaremos outras opções de editores de código e cadernos de anotações que não
precisam do Anaconda e que não vêm junto com ele.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 169

44. Outros Ambientes de Programação Python
44.1. Visual Studio Code
O VS Code (Visual Studio Code) é um editor de código poderoso que oferece inúmeros recursos para quem
programa em Python e em outras linguagens com foco em desenvolvimento Web (ou seja, se você quer construir
sites, este é uma excelente opção).

Ambiente do Visual Studio Code. À

primeira vista, parece ser bem
complicado de usar, mas com um
pouco de prática, tudo fica mais fácil!

É um excelente editor de código, pois

possui inúmeros recursos para
ajudar a completar e corrigir a sua
programação, no exato momento em
que você escreve o código.

É um concorrente à altura para o

Spyder.

44.2. Google Colab

Esta é uma ferramenta do google que substitui, com louvor, o Jupyter Notebook! Ela pode ser acessada no
endereço https://colab.research.google.com e requer uma conta gmail para funcionar.

Página do Google Colaboratory (a

gente que é mais íntimo chama só de
Google Colab).

É uma ferramenta que faz o mesmo

que o Jupyter Network faz, ou seja,
ela é útil para servir de “caderno” de
anotações quando a gente estuda
Python.

44.3. PyCharm – IDE Profissional para Python

A empresa JetBrains criou um dos melhores (senão o melhor) IDE para Python do mundo: o PyCharm. Este
ambiente traz inúmeros recursos para programadores profissionais e, sem dúvidas, não deve ser desprezado.

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 170

 Orra, João... se ele é tão bom, então
por que você não o recomendou
primeiro, antes dos demais?

Muito $imples, amigo leitor... $implesmente porque ele não é gratuito! (ele até era, e eu o usei bastante durante
algum tempo, ma$ a JetBrain$ decidiu não mai$ di$ponibilizá-lo gratuitamente, logo, nem todo mundo pode u$á-
lo agora!) – Eu optei por recomendar, apenas, ferramentas gratuitas para permitir o acesso de todos!

Ambiente do PyCharm da
JetBrains. Há, nele, muitos
recursos interessantes para
programadores profi$$ionais
(especialmente aqueles que já
podem pagar por tais
recursos!)

Acredito que não vai adiantar muito eu te perguntar

“qual é o melhor, então?” porque você provavelmente
vai dizer “depende de cada um”, certo?

Muito perspicaz você amigo leitor! Eu não vou recomendar, em si, nenhum grupo ou conjunto de
cadernos/ambientes/editores para você... Até agora, usamos apenas e tão-somente o próprio IDLE do Python
justamente para provar que podemos programar em qualquer um deles, mesmo o mais sem recursos de todos.

Sou de uma época de programação raiz, onde não havia auxílio, dicas, sugestões ou correções enquanto eu
digitava: eu simplesmente escrevia na tela branca e mandava rodar o programa... se algum erro acontecesse, eu
tinha que descobrir onde estava e corrigi-lo na mão!

Teste todos os ambientes e escolha o que melhor te atende... Mas tenha em mente uma coisa: o Anaconda é o
ambiente mais recomendado para análise e ciência de dados e o VS Code é o melhor para integração de código
Python com HTML, Javascript e outras linguagens usadas para construir sites.

Dependendo de você e do seu objetivo com o Python, um deles vai ser ideal!

Programação em Python – www.professorjoaoantonio.com.br - @ProfessorJoaoAntonio Página 171