Introdução à Programação Estruturada-v3_cópia

Prévia do material em texto

Introdução à Programação Estruturada 
Prof.: André Andrade 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[2] 
 
Sumário 
MÓDULO 1: APRESENTANDO O PYTHON ........................................................................................................................................................................ 5 
MÓDULO 2: OPERADORES, EXPRESSÕES E VARIÁVEIS ............................................................................................................................................ 5 
MÓDULO 3: ESTRUTURA CONDICINAL ........................................................................................................................................................................... 5 
MÓDULO 4: ESTRUTURA DE REPETIÇÃO ....................................................................................................................................................................... 5 
MÓDULO 5: FUNÇÕES ........................................................................................................................................................................................................ 6 
MÓDULO 6: STRINGS E ARQUIVOS................................................................................................................................................................................. 6 
MÓDULO 7: MATRIZES ....................................................................................................................................................................................................... 6 
MÓDULO 8: ESTRUTURA DE DADOS .............................................................................................................................................................................. 6 
MÓDULO 9: LISTAS ............................................................................................................................................................................................................ 6 
MÓDULO 10: DICIONÁRIOS ............................................................................................................................................................................................... 6 
MÓDULO 11: MODULOS ....................................................................................................................................................................................................... 6 
MÓDULO 12: BANCO DE DADOS....................................................................................................................................................................................... 6 
1. APRESENTANDO O PYTHON ..................................................................................................................................................................................... 7 
Paradigma ........................................................................................................................................................................................................................... 9 
Funcionamento: ................................................................................................................................................................................................................ 10 
Vantagens .............................................................................................................................................................................................................................11 
Desvantagens ......................................................................................................................................................................................................................11 
Exemplos de Linguagens Interpretadas .....................................................................................................................................................................11 
Funcionamento ................................................................................................................................................................................................................. 12 
Exemplos: ............................................................................................................................................................................................................................ 12 
Vantagens ........................................................................................................................................................................................................................... 12 
Desvantagens .................................................................................................................................................................................................................... 12 
Exemplos de Compiladores........................................................................................................................................................................................... 13 
Similaridades .................................................................................................................................................................................................................... 13 
Diferenças .......................................................................................................................................................................................................................... 13 
Aspecto...................................................................................................................................................................................................................................... 13 
Interpretadores ...................................................................................................................................................................................................................... 13 
Compiladores .......................................................................................................................................................................................................................... 13 
Exemplos ............................................................................................................................................................................................................................. 13 
E o que significa tudo isto em si? ............................................................................................................................................................................... 14 
Quem criou o Python? .................................................................................................................................................................................................... 15 
O que torna o Python especial? .................................................................................................................................................................................. 15 
É claro que o Python também tem os seus inconvenientes: ............................................................................................................................. 15 
Um projeto de programação de hobby ..................................................................................................................................................................... 16 
Objetivos do Python ........................................................................................................................................................................................................ 16 
PRIMEIRO ESCOLHA O SISTEMA QUE VAI INSTALAR E BAIXE O APLICATIVO ......................................................................................................17 
Introdução à ProgramaçãoProf.: André Andrade 
 
[27] 
22. Quais são os quatro elementos fundamentais que fazem uma linguagem? 
( ) Um alfabeto, fonética, fonologia e semântica 
( ) Um alfabeto, morfologia, fonética e semântica 
( ) Um alfabeto, um léxico, uma sintaxe e semântica 
( ) Um alfabeto, um léxico, fonética e semântica 
 
23. Qual é o componente esperado do seguinte programa? 
Print(“Hello!”) 
( ) o programa irá gerar uma mensagem de erro na tela 
( ) o programa fará output Hello! para a tela 
( ) o programa fará output “Hello!” para a tela 
( ) o programa fará output (“Hello!”) para a tela 
 
24. O que é CPython? 
( ) É a implementação padrão de referência do Python, escrita em linguagem C 
( ) É uma linguagem de programação que é um superset de Python, desenhada para produzir um desempenho semelhante a C, 
com o código escrito em Python 
( ) É a implementação padrão de referência da linguagem C em Python 
( ) É uma linguagem de programação que é um superset de linguagem C, desenhada para produzir um desempenho semelhante 
a Python, com o código escrito em linguagem C. 
 
25. Colocar V ou F: 
( ) Phyton é uma boa escolha para programação de baixo nível, por exemplo, quando se pretende implementar um driver eficaz 
( ) Python 3 é retrocompatível com Python 2 
( ) Python é uma boa escolha para a criação e execução 
( ) Phyton é gratuito , open source e multiplataforma 
 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[28] 
2. Operadores, expressões e variáveis 
Entender corretamente o problema que será trabalhado é fundamental para construir uma solução adequada. Infelizmente, muitos 
aprendizes falham nessa etapa e como consequência criam programas incorretos. Felizmente, existem estratégias que ajudam na 
resolução de problemas. 
2.1 Etapas para a solução de um problema 
Basicamente, programar é resolver problemas do dia a dia. Sem a capacidade de entender os problemas que nos cercam é difícil 
conseguir resolvê-los apresentando aplicar soluções com simplicidade, usabilidade e baixo custo, que são soluções que o mercado 
tende a abraçar. Mesmo conhecendo recursos avançados de linguagem de programação, se não tivermos a capacidade de resolver de 
forma eficaz os problemas, com uma usabilidade que requeira poucos conhecimentos dos operadores, não conseguiremos deslanchar 
os programas que desenvolvemos. Uma parte negligenciada pelos iniciantes em qualquer programação, no afã de aprenderem os 
comandos e os conteúdos que o ajudarão a programar, estes preferem os conceitos técnicos, é até uma normalidade no meio 
tecnológico, e a consequência é que muitas dessas pessoas terão dificuldades para criar aplicações adequadamente, pois não entendem 
corretamente qual o problema que estão tentando resolver (PRATHER et al., 2019). Em razão disso, é fundamental que além da parte 
técnica, aprender técnicas de resolução de problemas, antes de explorarmos o universo da programação. 
Segundo GOMES e Mendes, 2007 o processo de solução de um problema passa pela realização de 6 etapas: 
1. Entender o problema proposto; 
2. Caracterizar o problema; 
3. Representar o problema; 
4. Resolver o problema; 
5. Refletir na solução e; 
6. Comunicar a solução. 
2.1.1 Entendendo o problema 
Devemos pensar num programa como um conjunto de finalidades que possibilite a realizar um evento. Muitas vezes o problema não 
está explícito e requer leitura minuciosa e a interpretação de matérias que possam descrever o problema como textos, diagramas, 
manuais, livros especializados e outras informações que agregue ao conhecimento. Um programador ele não está só para escrever um 
código, ele está para facilitar o trabalho de um grupo de pessoas que enfrentam por problemas similares, e nem sempre vai ser fácil 
entender o que os usuários passam, sem o conhecimento adequado. Parar para entender o problema antes de ser uma máquina de criar 
códigos, pode facilitar no resultado final, otimizar o código para que possamos reutilizar partes do código e isso requer um entendimento 
do problema. Existe dois entendimentos de um problema, o entendimento de um dado programador, e o entendimento real do problema, 
e o que acontece com muitos programadores, é que de acordo com o que pensam ser o problema, começam a desenvolver o código ao 
mesmo tempo que acreditam estarem entendendo o problema, muitas vezes programadores diferentes entendem de forma diferente e 
é por isso que muitos códigos para uma mesma solução não serão iguais. Porém, sabe-se que realizar essas duas ações 
simultaneamente não é uma boa ideia devido à complexidade que apresentam (PRATHER et al., 2019). Como consequência, muitos 
aprendizes acabam por não entender o problema adequadamente e perdem um tempo considerável na criação de algoritmos incorretos. 
Em situações mais graves, não conseguem progredir, ainda que saibam os conceitos de programação. 
É importante, como programador, ter a mente aberta e procurar entender o que o problema propõe, principalmente para quem 
está começando, conter um pouco a ansiedade e aprender a ter uma visão mais clínica do problema, dedicar um tempo considerável 
em entender o problema, não é perda de tempo, é economia de tempo, já que uma vez que bem estudado as soluções técnicas irão ser 
melhor estruturada e em contrapartida refletirá em um código mais enxuto e efetivo. 
Como aprendiz, iremos ler enunciados que descrevem uma situação e criar algoritmos para efetuar a solução: como por exemplo: 
EX01: Ler quatro números do teclado que nomeamos de: A, B, C, e D, respectivamente. logo em seguida calcular o produto de A e B, 
chamaremos de X; e o produto de C e D, que chamaremos de Y. Por fim, subtraia Y de X e apresente o resultado em tela. 
Um erro no entendimento das operações matemática pode fazer com que o software criado calcule de forma errada, entregando 
um resultado incorreto. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[29] 
2.1.2 Caracterizar o problema 
 Construir uma visão sólida do problema é fundamental, e para isso é preciso identificar os conceitos principais do problema para 
um entendimento adequado. GUARDA et al., 2020 revela que a estratégia mais eficaz é entender os detalhes e particionar em partes 
menores o quanto possível. No exemplo 01 : do item 2.1.1 podemos ilustrar como esse problema pode ser subdividido em subproblema. 
• Subproblema 1: Ler quatro número do teclado; 
• Subproblema 2: O cálculo do produto entre eles, em que os resultados são nomeados de X e Y; 
• Subproblema 3: Realizar a Subtração de X e Y; 
• Subproblema 4: Apresentar o resultado em tela. 
Identificar o conjunto de subproblemas melhora o raciocínio do funcionamento do problema, fazendo um entendimento lógico sobre 
o que precisará ser resolvido nas etapas. Essa simples organização permite que um programador possa escrever o código de 
programação para cada subproblema e ao término, juntando todos os pedaços, terá resolvido o problema maior. 
Podemos também identificar a relação sobre eles, no caso do Subproblema 2, ele depende do subproblema 1, uma vez que para ser 
realizado é preciso que os número tenham que serem entrados no sistema. Dessa forma é importante associar o problema em questão 
a outros já resolvidos, e tentar lembrar de projetos similares para que possamos reaproveita-los, como também ajudará a clarear o 
entendimento; 
2.1.3 Representar o problema 
Neste ponto, devemos ter um entendimento, mesmo que parcial, sobre o problema e os detalhes que o compõem. Entretanto quando 
o nível de complexidade aumenta, pode ser que seja necessário a reorganização das ideias. 
O uso do recurso gráfico é excelente para ampliar o nível de entendimento do 
problema, e uma técnica amplamente usada para a organização das informações é 
o fluxograma. Apesar de existir outros formatos que poderíamos adotar, o 
fluxograma ainda é a mais comum adotada para a criação de códigos iniciais de 
programação (DE JESUS, 2011). Esse tipo de representaçãográfica expressas a 
sequencia de açãos ou etapas ou subproblemas que possuem qualquer relação umas 
com as outras. No exemplo do subproblema identificado no item 2.1.2 poderia ser 
representado em conjunto com a sequência que deveria ser resolvida. Como a 
seguir na Fig. 18. 
O fluxograma é muito útil por diversos motivos, mas poderíamos destacar: 
• capacidade de identificar 
• relação de ordem entre subproblemas 
• visualização do que precisa ser realizado 
existem outras formas de se representar um problema, escrever a lógica de 
resolução em português é uma delas, e é uma estratégia útil, já que o processo de 
criação de um código demanda um esforço cognitivo para a definição dos recursos 
de programação que serão utilizados, lembrança da sintaxe, entre outros (WANG e 
CHIEW, 2010). Já que melhorar o entendimento é o objetivo aqui, desenhar uma 
solução para o problema através de linguagem de programação mais irá atrapalhar 
do que ajudar. Primeiramente estamos pensando no problema proposto, mas 
lembre-se que como falam os nossos pais: “Costume de casa vai a praça”, e quando 
estivermos com um problema de mais de 1000 subproblemas? Lembre-se que na vida real, a quantidade de problemas a ser resolvido 
é enorme, entender passo a passo é importante para estruturar o conhecimento. A Gestalt ou Teoria da Forma é uma corrente de 
pensamento que propõe que a simples união das partes não explica o todo. Conforme um de seus principais autores, Max Wertheimer, 
a percepção humana é estruturada e organizada e, por isso, não deve ser reduzida a elementos menores, só que não se aplica na 
programação estruturada, ode a redução do problema em pedaços menores cria pequenos entendimentos do funcionamento do todo, 
então quando esses pequenos pedaços se juntam, temos a solução de um problema complexo, com muitas funcionalidades. Assim a 
proposta é de estabelecer um entendimento do problema, elaborando a lógica em português, a seguir um exemplo levando em conta um 
caixa de autoatendimento bancário: 
INÍCIO 
LER NÚMERO DO 
TECLADO 
CALCULAR PRODUTO E 
ARMAZANAR 
APRESENTAR 
RESULTADO 
FIM 
CALCULAR 
SUBTRAÇÃO 
FI
G
 18
 –
 F
LU
XO
GR
AM
A 
CO
M 
SE
QU
ÊN
CI
A 
DO
 S
UB
PR
OB
LE
MA
 ID
EN
TI
FI
CA
DO
 N
O 
EN
UN
CI
AD
O 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[30] 
1. Cliente entra com um cartão; 
2. cliente escolheu a opção de saque; 
3. requisitar o valor 
4. verificar se há saldo em conta, comparando o valor com o solicitado para saque 
5. se saldo positivo, subtrair o valor sacado do saldo bancário e liberar o dinheiro solicitado apresentando a 
mensagem: “ 
6. caso não suficiente, apresentar a mensagem: ”Saldo insuficiente” 
 
O TEXTO ACIMA ESTÁ EM LINGUAGEM DIRETA E COMPREENSIVEL A MAIORIA DAS PESSOAS, AJUDA AS PESSOAS 
ENVOLVIDAS VISUALIZAREM A SOLUÇÃO. 
2.1.4 Resolver o problema 
Aqui vamos capturar os recursos usados para criar uma solução para o problema proposto, já que planejamos tudo nas etapas 
anteriores que servirão de base para a nossas ações durante a escrita do código de programação. 
É muito importante ter definido o que precisa ser feito e pensar como o que foi definido pode ser implementado para virar um 
código. Agora deve-se pensar nos recursos técnicos de programação poderão ser usados. No caso do caixa automático, deve ser 
pensado em definir valores possíveis de saque de acordo com as notas armazenadas, criar uma interface gráfica, recursos de 
segurança para garantir que as notas não sejam entregues em caso de problemas. E o conhecimento técnico aqui é fundamental para 
o sucesso da programação. 
Erros podem ocorrer durante a escrita do código, seja pela alteração de ordem dos subprocessos, ou pela falta de entendimento 
correto do problema ou por não se saber como usar o recurso corretamente. Resiliência é importante aqui para poder vencer esta 
etapa e entregar o programa que resolve o problema proposto, e não se desesperar nem ficar ansioso, já que são sentimentos que 
cegam o programador. Logo experiencia e seguir as etapas é o meio mais fácil de se encontrar o sucesso. 
2.1.5 Refletir sobre a solução 
Refletir é um dos mais esquecidos, deve ocorrer ao final da criação de cada programa. É necessário refletir sobre a solução que 
foi encontrada, como também, sobre o caminho que o levou até ela. Subdividimos esta ação em duas, por entender que envolvem 
processos reflexivos diferentes. 
1- Avaliar a solução - pensamos no algoritmo, como melhorá-lo ou mesmo torná-lo mais eficiente (fazê-lo executar mais 
rapidamente); 
2- Preocupados em aperfeiçoar o processo, ou seja, as ações que realizamos até chegar ao produto final - entender o problema, 
escrita do código, entre outros. 
A reflexão passa por uma autoavaliação que deve acontecer do planejamento à execução, isso é um processo de maturação do 
produto criado. O programador as vezes lava as mãos e entrega o produto realizado, sem revisar o código ou testar repetidas vezes. 
Pensamos no que deu certo e tchau, quando o pensamento deve ser: Deu certo, e agora? o que pode ser melhorado? Mas não é só em 
código, devemos considerar as nossas dificuldades no processo como um todo, e no que teve maiores dificuldades buscar 
aperfeiçoamento para em uma próxima atividade ser mais natural. 
Além dos elementos descritos anteriormente, podemos a princípio compreender como um processo rígido e burocrático a criação 
de um programa. Podemos realizar apenas parte delas e apenas quando julgar necessário a depender da complexidade do problema, da 
familiarização e nível do programador, pode-se não precisar representar o problema. 
Isto é parte de um ciclo, onde as ações são realizadas em uma sequência e retornam ao ponto inicial e base para tudo: o 
entendimento do problema. Também tenha atenção para o fato de que, em muitos casos, será preciso realizar o ciclo múltiplas vezes 
para conseguir construir uma solução adequada, grande parte dos projetos usam ciclo PDCA (Plan; Do; Check; Act) que é um método 
iterativo de resolução de problemas baseado em quatro estágios que focam em melhorar a eficiência dos processos de trabalho, foi 
criado por Walter A. Shewhart na década de 1920. (O PDCA tem foco na melhoria contínua de processos, gerenciamento de mudanças e 
gestão da qualidade). 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[31] 
Na prática, muitas das ações descritas já poder serem realizadas, que já são reconhecidos como importantes na criação dos 
algoritmos. Melhoria contínua na realização dessas ações, de forma que o conhecimento adquirido em um ciclo vai alimentar a realização 
do próximo. Portanto, as lições aprendidas por você devem ser utilizadas para evitar cometer os mesmos erros e repetir as ações que 
deram um bom resultado. 
2.2 Variáveis 
2.2.1 Dados que nos cercam dia a dia 
Perguntas como: Idade? Nome? Endereço? Símbolo que representa uma operação, geralmente 
todos tem as respostas na ponta da língua, mas que se for perguntado para pessoas diferentes a 
resposta poderá ser diferente. Esses dados estão armazenados na memória de cada pessoa, que ao 
memo tempo, é capaz de recuperá-los sempre que necessário, como exemplo: 
Qual o seu nome? O Cérebro, pesquisa o canto da memória e manda para a boca para ser pronunciado 
 
 
 
Assim como seres humanos, programa também armazenam dados, um jogo de tiro precisa armazenar a quantidade de munição, os 
tipos de armas de um dado jogador, onde o jogo parou. 
DADOS ARMAZENADOS POR UM PROGRAMA UTILIZA O CONCEITO CONHECIDO COMO VARIÁVEIS. 
As variáveis são itens indispensáveis para qualquer programa, dos menores aos gigantescos, como o WhatsApp para receber a 
digitação de um texto, nomes do contato, textos descritivos do contato, e esses valores são alterados de usuário para usuário. No Word, 
o texto que digitamos a cor de um texto ou o tipo de fonte, então tudo o que pode ser alterado e uma variável, e que necessitam ser 
armazenados. Vimos que programar é resolver problemas, criarsoluções computacionais para o cotidiano. E para entender o problema 
e desenhar a solução precisamos identificar as variáveis que usaremos no software, nos dados que transitarão na aplicação, seja pela 
entrada do usuário, por exemplo um valor de saque, seja a saída resultante de um processo como o saldo resultante na conta bancária 
após um saque. Uma variável é criada para cada dado que será armazenado por um programa. Por exemplo num editor de texto nos 
temos um tipo de fonte Agency FB, de tamanho 10 e preciso entender o que é o dado e qual a variável. No caso em questão o Tipo de 
fonte e o tamanho são variáveis, que é onde vai ser armazenado os valores e que podem ser alteradas a qualquer momento, e o a Agency 
FB e 10 são os dados a serem armazenados. No dicionário variável é aquilo “sujeito a variações ou mudanças; que pode variar;”. 
Variável Dado 
Tipo de fonte Agency FB 
Tamanho 10 
TABELA02 – TABELA VARIAVEL X DADO ARMAZENADO 
2.2.2 Estrutura de uma variável 
Uma variável possui uma estrutura, e o Python tem uma forma de se fazer. Uma vez que as variáveis têm função de armazenar 
dados. Nós seres humanos temos uma memória sofisticada capaz de armazenar um grande volume de dados, durante nossas vidas 
conseguimos reter bilhões de informações, muitas muito sutis que de tão complexas que são muitas vezes não conseguimos expressar 
em palavras. Segundo NORMAN, 2013, muitas vezes rotulamos as nossas memorias para facilitar a recuperação das mesmas quando 
precisamos, isso ocorre quando associamos uma placa do carro PSD-1981 ou a senha do cartão de crédito que é 132465. 
Etiqueta Dado Armazenado 
Placa do carro PSD-1981 
Senha do cartão 132465 
TABELA03 -TABELA DE ASSOCIAÇÕES ETIQUETA X DADO 
 
ANDRÉ 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[32] 
Na programação rotulamos, etiquetamos os dados que serão armazenados para que possamos resgatá-los de forma fácil quando 
for necessário. E não é nada difícil com dezenas ou milhares de variáveis num programa, as coisas possam se descontrolar se não for 
bem identificada para que possamos encontrar de forma fácil sempre que necessário. Nos exemplos dados acima podemos tentar 
lembrar: em qual variável guardamos as informações sobre o tamanho da fonte escolhida? Ou o tipo de fonte? E poderíamos exemplicar 
etiquetas como: 
Etiqueta Dado Armazenado 
Tipo_fonte Agency FB 
Tamanho_fonte 10 
texto Este, é um texto útil. 
TABELA04 -TABELA DE ASSOCIAÇÕES ETIQUETA(VARIÁVEL) X DADO NA PROGRAMAÇÃO PYTHON 
VARIÁVEIS SÃO FORMADAS POR UM NOME E VALOR(DADO) 
Importante: Quem define o nome da variável é o programador, e pode ser qualquer coisa que faça sentido para ele. Mas existem 
regras e recomendações que precisam serem seguidas como: 
Restrição Nomeação Incorreta Forma Correta 
Não deve ter acentos10, pontuação pontuacao 
Caracteres especiais como @$%^, outros11 total_dinheiro$ total_dinheiro 
Começar com números 3nota terceira_nota 
Ter espaços nome de usuario nome_de_usuario 
TABELA05 -TABELA DE RESTRIÇÕES PARA CRIAÇÃO DE UMA VARIÁVEL, FORA ERRADA DE SE FAZER E A CORREÇÃO 
Além das restrições, existem as boas práticas ao nomear variáveis. Primeiro os nomes devem representar o dado que a variável 
armazena. Supondo uma variável s, o que ela armazena? Essa letra pode ter uma infinidade de significado, para uma pessoa pode ser 
uma senha, para outra pode ser salário armazenado dos funcionários. Então é importante nomear bem uma variável, de forma que seja 
indubitável o que estamos armazenando nela e não gerar confusão. Então, usemos nomes que caracterizam a variável. A variável 
pontuacao é adequado para armazenar a pontuação alcançada em um jogo (evitar acentos gráficos). Armazenar um número de telefone, 
pode-se nomear de telefone ou numero_telefone (não podemos ter espaços!). E para armazenar o login de um usuário podemos criar 
login_usuario. Devemos perceber que certas variáveis foram formadas por mais de uma palavra. E não se podemos ter espaços entre 
elas, a prática recomendada pelo Python é omitir preposições e artigos, como também separar as palavras com _ (subtraço), veja que 
não é obrigatório, mas tornou-se uma boa prática de desenvolvimento, deixando mais elegante o código e de fácil visualização. O Python 
é Case Sensitive, no geral e não seria diferente para os nomes das variáveis. Então: total_fotos; TOTAL_FOTOS; total_Fotos e Total_Fotos, 
como qualquer variável das mesmas letras nas mesma sequencial mudando a caixa da letra, representam variáveis distintas. 
Por exemplo: 01100001 = a e 01000001 = A, assim como: 01100010 = b e 01100100 = B 
Logo: assim como 011000001 01000001, a A  para o computador a comparação é diferente igualdade so se dá 
quando diante da execução de uma subtração o resultado é nulo e: 
 01100001 01100001 
-01100001 só que: - 01000001 
 00000000 00100000  Que é diferente de zero 
VARIÁVEIS SÃO FORMADAS POR UM NOME E VALOR(DADO) 
Se quiser dar um nome a uma variável, deve seguir algumas regras estritas: 
• o nome da variável deve ser composto por letras maiúsculas ou minúsculas, dígitos e o caratere _ (underscore) 
 
10 e 11A partir do Python Versão 3 é possível usar esse recurso, porém não é muito comum nem indicado. 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[33] 
• o nome da variável deve começar com uma letra; 
• o caractere underscore é uma letra; 
• letras maiúsculas e minúsculas são tratadas como diferentes (um pouco diferente do que no mundo real - Alice e ALICE são 
os mesmos nomes próprios, mas em Python são dois nomes de variáveis diferentes, e consequentemente, duas variáveis 
diferentes); 
• o nome da variável não deve ser nenhuma das palavras reservadas de Python (as keywords). Ou seja, não podemos criar 
variáveis como: ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'] 
 
NOTA: O PEP 8 — Style Guide for Python Code recomenda a seguinte convenção de nomenclatura para variáveis e funções 
em Python 
o os nomes de variáveis devem ser em letras minúsculas, com palavras separadas por underscores para melhorar a 
legibilidade (por exemplo, var, my_variable) 
o os nomes de funções seguem a mesma convenção que os nomes de variáveis (por exemplo, fun, my_function) 
o também é possível utilizar um caso misto (por exemplo, myVariable), mas apenas em contextos em que esse já é o 
estilo predominante, para manter a retrocompatibilidade com a convenção adotada. 
2.2.3 Criando variáveis em Python: 
Temos que ter sempre em mente que: Toda variável possui um 
nome e que ela sempre armazenará um dado, o que gera o 
conhecimento da sintaxe de uma variável. Ilustraremos abaixo como 
armazenar um tamanho de fonte num editor de texto qualquer: 
 
tamanho_fonte = 10 
 
Se não percebeu, este é um código de programação, simples e direto, que diz: a variável de nome tamanho_fonte guarda 
o dado 10. Você imaginaria que os aplicativos, jogos e outros programas usam instruções parecidas como esta acima? O código escrito 
possui apenas uma instrução 
tamanho_fonte = 10 
nome da variável Dado que será guardado 
 
Precisamos respeitar esse formato, uma regra conhecida como sintaxe. E só assim o computador será capaz de entender que se 
deseja criar uma variável e armazenar um dado nela. Quebrando em partes a sintaxe: 
 
Parte Descrição 
tamnho_fonte É a primeira informação que deve se escrever para indicar qual será o nome da variável 
Sinal de = (igualdade) É o operador de atribuição, e são usados para separa o nome do dado a ser armazenado 
10 Representa o dado a ser armazenado na variável 
TABELA06 -TABELA DE SINTAXE, DESMENBRANDO UMA LINHA DE VÁRIAVEL PYTHON 
 
2.2.4 Modificando o dado de uma variável 
O nome variável é este pelo simples fato de variar, ou seja,de poder modificar o dador nela armazenado como a seguir: 
 
tamanho_fonte = 10 
tamanho_fonte = 15 
 
Um algoritmo pode ter milhões de linhas, no caso acima tem duas linhas: Pergunta-se, na sua opinião qual o valor armazenado na 
variável tamanho_fonte? Precisamos lembrar como um computador lê um algoritmo, da esquerda para a direita e de cima para 
baixo, linha a linha. Quando acaba uma linha, vai para a próxima até que não exista mais linhas, ou encontre o comando para encerrar. 
Então no código acima, o computador lerá a primeira linha e armazenará o valor 10, em seguida segue para segunda linha e modificará 
o valor para 15. Esse exemplo ilustra a execução de uma linha de código que é afetada pela linha seguinte. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[34] 
2.2.5 Recuperando dados 
Além de armazenar dados, outra característica marcante das variáveis é a que elas também permitem recuperar o que foi 
armazenado. 
tamanho_fonte = 10 
aplicando_fonte = tamanho_fonte 
No algoritmo acima, a variável tamanha_fonte armazena o dado 10, mais adiante, a variável aplicando_fonte, 
resgata o valor aplicado na variável tamanho_fonte para usar noutra parte do programa. Este é um exemplo importante, pois é 
um conceito que demonstra o acesso ao dado de uma variável pode ser feito por seu nome. Além disso, podemos perceber que é possível 
recuperar a informação de uma variável e armazenar em outra variável, e no final do código teremos duas vereáveis armazenado o 
valor 10, cada uma. Mas e se eu altero o valor da variável inicial? Exemplo: 
 tamanho_fonte = 10 
aplicando_fonte = tamanho_fonte 
tamanho_fonte = 20 
Primeiro iremos armazenar o valor de dado 10 na variável tamanho_fonte, agora aplicamos o valor de tamanho da fonte 
em aplicando_fonte, e então altera-se o valor de tamanho da fonte para 20. O resultado que teríamos ao término do programa 
é que: aplicando_fonte teria 10 armazenado como dado, e tamanho_fonte terá armazenado 20 como dado. Ou seja, 
não altera o aplicando_fonte, que foi carregado antes da alteração aplicada no tamanho_fonte, como sabemos o 
computador lê código fonte, linha por linha, da esquerda para direita, de cima para baixo, salvo se houver alguma condição de desvio. 
AO MODIFICARMOS O DADO DE UMA VARIÁVEL JÁ CRIADA, O DADO ANTERIOR É DESCARTADO. 
NOTA: Um problema comum que ocorre durante o uso de variáveis, é solicitar o uso dela, antes dela ser declarada. 
 aplicando_fonte = tamanho_fonte 
tamanho_fonte = 15 
A linha 1 cria uma variável aplicando_fonte para armazenar tamanho_fonte. Neste caso a variável ainda 
não existe, pois só foi declarada na linha 2. O Python acusará um erro tipo NameError, que ocorre ao usar, entre outros 
motivos, uma variável inexistente. 
ERROS ACONTECEM QUANDO USAMOS VARIAVEIS AINDA NÃO DECLARADAS 
Erros fazem parte da criação de qualquer programa, um bom profissional encara um erro mais como um desafio do que como uma 
frustração. 
2.2.6 Variáveis numéricas 
Ao se apresentar número, torna-se preciso se considerar diferenças existente na matemática tradicional. Números grandes não 
se representa com pontos e virgulas, 1.000.000 se representa 1000000. A seguir um algoritmo que armazena o valor de um salario 
minino de R$ 1.412 (mil quatrocentos e doze reais). 
salario = 1412 
Observe a ausência de ponto entre o numero 1 e o numero 4. Precisamos entender que os valores 1412 e 1.412 são dados diferentes 
na programação. O primeiro representa 1412 (mil quatrocentos e doze)e o segundo representa 1,412 (um seguido de 412 milésimos). 
Simbolos como R$, % e outros, não podem ser utilizados em declarações de variáveis numéricas. Outra diferença está nas casas 
decimais, conhecidas na programação por “flutuantes”(floating). No brasil usamos vírgulas, e na programação devemos usar o ponto. 
Salário R$ 1.412,00. 
salario = 1412.00 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[35] 
A forma que representamos números percentuais também se difere. Você se depara com a necessidade de guardar todo mês 10% 
do salário para possíveis emergências 
fundo_emergencial = 10% 
No entanto em Python, o símbolo %, como $, @ e outros não são usados com essa finalidade. Para apresentar esses número 
precisamos saber os conceitos, onde: 10 % = 10
100
 =0,1 (para converter qualquer número em porcentagem, basta dividi-lo por 100) assim: 
fundo_emergencial = 0.1 
É importante entender como armazenar os dados percentuais, pois são bastante habituais em programação. O Python não aceita 
símbolos diversos na declaração de números. Indicar um numero que representa uma quantidade em dinheiro, é igual o mostrado na 
variável salario acima, note que não leva o $, ou R$ ou £ entre outros que devem ser ignorados, e os centavos, usa-se o ponto 
como delimitador. 
2.2.7 Variáveis que armazenam palavras/textos (Strings) 
Os programas precisam também armazenar texto, palavras, nomes etc., não números, se não fosse assim o que seria de um editor 
de texto, ou mesmo de um comunicador de mensagem. Na programação, variáveis que armazenam texto são denominadas de STRNGS. 
As variáveis Strings possuem uma características especial, pois seus valores devem estar entre “ ” ou ‘ ‘ (aspas, duplas ou simples). 
Ex: 
texto_escrito = “Este soverte é muito bom, quero mais!” 
texto_argumentativo = ‘Você poderia me ensinar a fazer este sorvete?” 
NOTA: CASO TENTE DECLARAR UMA VARIÁVEL STRING SEM AS ASPAS O PYTHON CAUSARÁ UM TIPO DE NameError OU SyntaxError. 
NÃO SE PODE MISTURAR ASPAS SIMPLES COM ASPAS DUPLAS, COMEÇOU COM ASPAS SIMPLES TERMINA COM SIMPLES. 
Sabemos que as strings precisam de aspas, agora como representar uma aspa dentro de uma string? Supomos ter que 
apresentar em tela a mensagem: Eu gosto de “Monty Python”. Como fazemos isto sem gerarmos um erro? em duas formas 
que falaremos melhor mais adiante, mas que será mostrado para que tenhamos a certeza, que para tudo sempre há uma 
saída, mesmo que não seja a mais óbvia, e que não se apresente de imediato na mente do programador, mas existe. 
1 – print(“Eu gosto de \”Monty Python\””) 
1 – print(‘Eu gosto de “Monty Python”’) 
Há uma sintax especial usada apenas para criação de textos que irão ocupar múltiplas linhas. 
Texto = “”” 
primeira linha 
segunda linha 
terceira linha 
“”” 
O PROCEDIMENTO PARA ACESSOAR DADOS DE VARIÁVEIS STRINGS NÁO DIFEREM DOS 
PROCEDIMENTOS DAS VARIÁVEIS NUMÉRICAS. 
texto_escrito = “Este soverte é muito bom, quero mais!” 
pensamento = texto_escrito 
Na primeira linha é criado a variável texto_escrito, na segunda linha é criado a variável pensamento que armazenará 
o dado contido na variável anterior. 
OBSERVAR QUE UMA VARIÁVEL QUE VAI RECEBER UM VALOR DE OUTRA VARIÁVEL STRING, NÃO 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[36] 
PRECISA SER ASPEADO, CASO VOCÊ COMETA O ERRO O RESULTADO SERÁ DIFERENTE DO ESPERADO. 
As variáveis Strings também podem armazenar números, mas neste caso eles não são números puros, são variéveis de texto e não 
podemos usar para uma equação. 
texto_escrito = “2” 
A variável texto_esrito não armazena o número dois, armazena uma String cujo é um texto 2. Em princípio não entendemos a 
diferença entre “2” e 2, mas é importante se entender que ambos são diferentes para o computador em aspecto de comportamento. O 
dado 2 e a String “2”, implicam que operações matemáticas só podem ser realizadas no Dado 2, a String não. Mas podemos realizar 
algumas operações em Strings, como unificar um texto de duas variáveis. Vamos considerar um programa que tem duas variáveis, uma 
para armazenar o nome e a outra o sobrenome: 
primeiro_nome = “André” 
segundo_nome = “Andrade” 
Agora vamos criar uma terceira que armazene o nome completo. O resultado será um texto Único: André Andrade , ao 
processo de união de variáveis Strings é Concatenação. E o operador que iremos usar é o sinal de soma (+): 
primeiro_nome = “André” 
segundo_nome = “Andrade” 
nome_completo = primeiro_nome + segundo_nome 
A concatenaçãoé realizada através da variável nome_completo, e o seu valor é o texto André Andrade, formado a 
partir das variáveis primeiro_nome e segundo_nome. 
A concatenação pode ser feita com um texto e uma String. 
primeiro_nome = “André” 
saudacao = “Olá” + primeiro_nome 
A concatenação só funciona com variáveis String. Ao tentar executar a concatenação de um número com uma String, o python 
acusará um erro do tipo TypeError. 
numero = 10 
texto = “a” 
resultado = numero + texto 
TENTAR COLOCAR SIMBOLOS DE ASPAS DENTRO DE UM TEXTP PODE OCASIONAR UM PROBLEMA. 
texto = “Exemplo com o símbolo de ” (aspas)” #Apresenta um erro 
O texto apresenta três aspas, a primeira e a última são usadas na declaração String, a aspa do meio faz parte do texto. O código 
ocasionará um erro, o computador não vai entender qual a sua intenção, e utiliza a do meio apara encerrar as aspas. É muito simples, 
só pode ter uma aspa que abre a entrada da String e uma que fecha. Mas eu preciso representar as aspas no texto, é importante como 
fazer? Falamos que se começarmos a entrada de uma String com aspas simples tem que terminar com aspas simples, e com aspas 
duplas tem que terminar com aspas duplas, então essa é a solução. 
texto = ‘Exemplo com o símbolo de ” (aspas)’ #Não apresenta erro 
A segunda forma utiliza um operador de escape \ (barra invertida) antes do símbolo de aspas. Seu uso possibilita combinar texto 
entre aspas duplas e o uso deste pipo de aspas. 
texto = “Exemplo com o símbolo de \” (aspas)” #Não apresenta erro 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[37] 
A barra invertida não aparecerá na saída deste código e resultará em: Exemplo com o símbolo de ” (aspas) 
2.2.8 Variáveis Booleanas 
As variáveis booleanas são um tipo especial de dados que talvez possamos não conhecer, mas que será usado com grande 
frequência em programação. Vamos usar como exemplo um comunicador qualquer, se o celular está conectado à internet o comunicador 
vai apresentar o usuário como: Online, e quando não houver o sinal o comunicador o colocará como Offline. É importante que se entenda 
que não existe meio termo em booleanos, ou é ou não é. Existe Conectado e não Conectado, e não existe estou “Meio Conectado”. Agora 
iremos usar uma assistente virtual para ligar e desligar uma tv. Primeiro precisamos saber se a tv está desligada ou se estar ligada, 
visto que o comando é o mesmo para ligar e desligar a TV. Por exemplo, você sai de casa e não se lembra se deixou a TV desligada, então 
ela está ligada e desligada para o assistente virtual, como o comando é o mesmo, se você diz: Alexa, desligar a TV, ela vai responder 
tudo bem, vai mandar um sinal para o receptor infra vermelho de desligar a TV, o receptor vai mandar um comprimento de onda de 
desligar a TV, que por sua vez é o mesmo comprimento de onda para ligar a TV. Se você não tiver certeza, e a TV estiver desligada, você 
irá ligar a TV. Existem equipamentos como o AR CONDICIONADO que o comando para ligar e desligar, através do mesmo receptor são 
diferentes, então se você solicita para a assistente virtual para DESLIGAR, não interessa o estado do equipamento ele vai ser desligado 
se estiver ligado, e não surtirá efeito se o equipamento já estiver desligado. As situações que apresentam apenas duas possibilidades 
de valores são denominadas de tipo booleano e são usadas para representar um valor muito abstrato truthfulness(veracidade). Cada 
vez que se efetua uma comparação tipo a > b? a pergunta resulta na criação de dados específicos com valor Booleano. O nome vem de 
George Boole (1815-1864), autor da obra funtamental, As leis do Pensamento, contendo definições de álgebra Booleana, que faz uso 
apenas de dois valores distintos: True(verdadeiro) e False (falso), denotado como 1 e 0, e que podem ser usados para representar 
inúmeras situações. Em Pyton seria: 
usuario_conectado = True 
tv_ligada = False 
NOTA: não se pode mudar nada, incluindo o fato de serem sensitivity-case 
print(True > False) 
print(True (maior que); >= (maior ou igual a), (diferente de) 
O operador maior que tem outra variante não estritam mas que é denotada de forma diferente na aritimética clássica: >= (maior 
ou igual a) que seria ≥. Existem dois sinais subsequentes, não um. Ambos os operadores, escritos e não escritos), bem como os outros 
dois discutidos == e !=, são operadores binários com ligação à esquerda, e sua prioridade é maior do que a mostrada por == e 
!=. 
Da mesma forma o =qtd_ovelhas 
print(comparativo) 
A outra possibilidade é mais conveniente e comum, podemos usar a resposta para obter tomadas de decisões futuras sobre o 
programa. Mais adiante teremos uma tabela 09 de prioridades completa com todos os operadores e a ordem de prioridades, na tabela 
07, temos apenas a ordem de prioridades binária, ou seja com resposta sim ou não. 
Prioridade Operador 
4 +, - 
Binário 5 , >= 
6 ==, !== 
TABELA 07 – LISTA DE PRIORIDADES BINÁRIA 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[39] 
TIPO DE COMPARAÇÃO 
REPRESETNAÇÃO 
MATEMÁTICA 
REPRESENTAÇÃO 
PROGRAMAÇÃO 
EXEMPLO 
MAIOR QUE > > 10 > 5 
MENOR QUE = 5 >= 3 
MENOR OU IGUAL QUE ≤E NA MATEMÁTICA 
2.2.9 Tipos de dados 
No Python há um conjunto de dados tipificados que permite representar diferentes situações, números inteiros, decimais, textos e 
variáveis booleanas e outros que serão introduzidos no momento certo. E importante entender que o dado armazenado numa variável 
é quem indica o tipo de variável. E o tipo de variável restringe o tipo de operações realizadas com ele. Cálculos matemáticos só podem 
ser realizados com variáveis numéricas, assim como uma concatenação só pode ser realizado com variáveis Strings O programador 
deve entender isso para não trocar os tipos de dados e entender as características das variáveis em Python, e assim ter sucesso em 
seus códigos fontes: 
numero = 2  variável numérica 
numero = "2"  variável String 
print (2) 
print(“2”) 
resultado: 
2 
2 
Literal 
Um literal é u dado cujo os valores são determinados pelo próprio literal, é um conceito não muito obvio. Por exemplo: 
123 
Consegue adivinhar que valor ele representa? É obvio que é cento e cinte três. Mas, e quanto a este outro exemplo? 
c 
Representa algum valor? Talvez. Pode ser o símbolo da velocidade da luz, pode ser a constante de integração, o comprimento da 
hipotenusa... existe enumeras possibilidades, e não se pode escolher o certo sem algum conhecimento adicional, e esta pista: 123 é um 
literal, já c não é. Usamos literais para codificar dados e para os colocar no seu código. Em Python algumas condições devem ser 
obedecidas. No caso do comando print(2) e print(“2”) o resultado é idêntico, embora um é uma String e o outro um número 
inteiro., apesar de ambos se apresentarem exatamente da mesma forma, e os dois valores foram armazenados de formas 
completamente diferentes. 
EXTRA: Há mais um literal especial que é usado em Python: o literal None. Este literal é um chamado NoneType objeto, e é 
utilizado para representar a ausência de um valor. 
Inteiros 
Podemos já saber o que são números inteiros da matemática do conjunto Z={..., -3, -2, -1, 0 , 1, 2, 3, ...} , números decimais. E 
sistema binário? É o sistema que os computadores usam para armazenar os números e que podem realizar qualquer operação. Não 
iremos expor a complexidade dos sistemas de numeração posicional, mas vamos dizer que números tratados pelos computadores 
modernos são de dois tipos: 
 
 
 
 
Esse procedimento ocasionou uma 
mudança do tipo da variável que iniciou 
numérica e finaliza como String 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[40] 
• Inteiros, os que são desprovidos da parte fracionada; 
• Ponto-flutuante (floating point ou só float), que contêm ou são capazes de conter a parte fracionada. 
Esta definição não é exata, mas por hora serve par desenvolver a ideia, já que a distinção é importante, e a fronteira entre os dois 
tipos de número é bem rigorosa. E ambos os tipos diferem no formato de como são armazenados na memória do computador, como 
também no intervalo dos valores aceitáveis. A característica do valor numérico que determina o seu tipo, intervalo e aplicação é o type. 
Se codificarmos um literal e o colocarmos dentro do código Phyton, a forma do literal determina a representação (type) que o Python 
usará para armazenar na memória. 
Nos inteiros, o processo é quase como escrevê-los à lápis no papel – é simplesmente uma String de dígitos que compõem o número, 
entretanto há uma reserva – não se deve interpor qualquer caractere que não sejam dígitos dentro do número, um número como onze 
milhões cento e onze mil cento e onze, se pagássemos um lápis e escrevêssemos desta forma: 11,111,111, ou assim: 
11.111.111, ou mesmo assim mesmo: 11 111 111. é evidente que esta posição facilita a leitura, especialmente quando o 
número é composto por muitos dígitos, no entanto, o Python não aceita coisas como estas, e é proibido a utilização. O que o Python 
permite, no entanto, é a utilização de underscores em literais numéricos, logo: podemos escrever este número desta 
forma:11111111, ou assim: 11_111_111. 
NOTA: Python 3.6 introduziu underscores em letras numéricas, permitindo a colocação de underscores únicos entre dígitos e após 
especificadores de base para melhorar a legibilidade. Este recurso não está disponível em versões mais antigas de Python. 
Como escrever números negativos em Python? Como de costume – adicionando um menos, e podemos escrever: -11111111, 
ou -11_111_111. Como na matemática clássica, números positivos não precisam serem precedidos por um sinal positivo, mas 
não lhes e negado se o deseja fazer. As linhas se equivalem: +11111111 e 11111111. 
Números octais e hexadecimais 
No Python há duas convenções adicionais e que não são comuns na matemática, a primeira permite que seja utilizado numa 
representação octal. Se o número inteiro for precedido por um 0O ou 0o prefixo (zero-o), este será tratado como um valor octal, e 
isto significa que o número deve conter apenas dígitos retirados do intervalo de [0 à 7]. 0o123 é um número octal com um valor 
(decimal) igual a 83. A classe print() faz a conversão automaticamente. 
Print(0o123) 
A segunda convenção permite usar números hexadecimal, e que devem ser precedidos pelo prefixo 0x ou 0X(zero-x), por 
exemplo 0x123 é um número hexadecimal com o valor decimal equivalente a 291. E s função print() faz a conversão 
automaticamente: 
Print(0x123) 
Experimente fazer Print(0b101001) e observe o que acontece. 
Floats 
As frações decimais não vazias, são números que contém ou pode conter a parte fracionada após um ponto decimal, é uma definição 
rasa, mas suficiente para entendermos o conceito. Exemplos de números de floating-point: 2.5; - 0.4 
NOTA: por mais que o número 2,5 pareça ser normal quando se escreve em um programa, e se o normal é usar uma virgula ao 
invés de um ponto, temos que assegurar em Python, que o número não contenha uma vírgula. 
Em Python temo: zero ponto quatro: 0.4 – ou pode se escrever zero ponto quatro apenas assim: .4 (omitindo o zero) da mesma 
forma que quatro ponto zero: 4. 
Veja os dois números: 4 e 4.0  Pode-se pensar que são exatamente os mesmos, mas em Python os vê de forma 
diferente, o 4 é um número inteiro, ao passo que o 4.0 é um floating-point. Vamos considerar a velocidade da luz, expressa em 
m/s, estrita diretamente: 300000000, mas para evitar tantos zeros, os livros ensinam a usar potência, que seria 3 x 108(três 
vezes dez elevado à oito). E em Python o mesmo efeito é seguido de uma forma ligeiramente diferente 3E8. A letra E (também pode 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[41] 
ser usada em minúscula e – provém da palavra expoente) e é registro conciso da frase dez à potência de. 
 NOTA: 
• O expoente (valor após o E) deve sempre ser um inteiro; 
• A base (valor à frente do E) pode ser um inteiro. 
Codificação de floats 
Para registrar números muito pequenos usamos esta convenção, no sentido de seu valor absoluto, e que está próximo a zero. Uma 
constante física chamada de Constante de Planck, é denotada com um h, e tem valor igual a 6.62607 x 10-34. Em Python 
teríamos: 6.62607E-34 
NOTA: o fato de se ter escolhido uma das formas possível de valores float, não significa que o Python a apresente da mesma forma. 
O Python pode escolher uma notação diferente da sua, digamos o float literal: 0.0000000000000000000001 quando 
executamos o comando print(0.0000000000000000000001) o resultado será 1e-22. E o Python sempre irá 
escolher a forma mais econômica de representação. 
2.2.10 Operações Matemáticas 
Agora que entendemos que variáveis podem ou não sofrerem operações matemáticas. Um operador é um símbolo da linguagem 
de programação, que é capaz de operar sobre os valores. Processar operações matemáticas com precisão e velocidade, é um dos 
grandes poderes dos computadores. Podemos realizar multiplicações, divisões, entre outras de forma tão rápidas, e com tanta 
segurança que se quer duvidados dos resultados apresentados. Jogos realizam muitas contas matemáticas, ojogo Fortnite, as armas 
são verdadeiras calculadoras de soma e subtração, todo disparo deve ser subtraído do total de balas que o jogador tem, assim como 
saber se o adversário foi atingido, a barra de saúde diminui a cada tiro, possibilitando fazer com que o jogador perceba nitidamente 
qual a sua vantagem em relação aos adversários. Vejamos: 
Quantidade_balas = 50 – 1 
 
Há diversas possibilidades de 
operações matemáticas, mas 
compreender as pequenas 
diferenças nos símbolos usados em 
comparação a matemática 
tradicional. A seguir teremos o 
exemplo de um programa que 
executa operações matemáticas: 
TABELA09 -TABELA DE SÍMBOLOS X OPERAÇÃO MATEMÁTICA CORRESPONDENTE 
# PROGRAMA QUE EXECUTA OPERAÇÕES MATEMÁTICA COM AS VARIÁVEIS a E b 
a = 10 
b = 3 
 
#operações 
soma = a + b # 13 
subtracao = a – b # 7 
multiplicação = a * b # 30 
divisão = a / b # 3.333... 
divisão_inteira = a // b # 3 
modulo = a % b # 1 
exponencial = a ** b # 1000 
 
Símbolo Operação 
+ Soma 
- Subtração 
* Multiplicação 
/ Divisão 
** Exponenciação 
// Divisão Inteira 
% (Módulo)Resto da divisão 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[42] 
Lembre-se: É possível formular as seguintes regras com base neste resultado: 
• os dados e os operadores, quando ligados entre si, formam expressões. A expressão mais simples é um literal 
em si. 
• quando ambos os argumentos ** são inteiros, o resultado é também um inteiro; 
• quando pelo menos um argumento ** é um float, o resultado é também um float. 
• o resultado produzido pelo operador da divisão é sempre um float, independentemente de o resultado 
parecer ou não ser um float à primeira vista: 1 / 2, ou se se parecer com um inteiro puro: 2 / 1. (Isto é um 
problema? Sim, pode ser. Acontece por vezes que é realmente necessária uma divisão que forneça um valor 
inteiro, não um float. Para isso usamos o sinal // - dupla barra) 
• Operadores: remainder (modulo) não existe equivalentes entre os operadores aritméticos tradicionais, sua 
representação gráfica em Python é o sinal % (percentagem), o que pode parecer um pouco confuso. Embora o 
resultado do operador é um remainder (resto) deixado após a divisão inteira, o valor que sobra de uma divisão 
Ex: 5/2 =2.5 e sobra 1 logo print(5%2) resulta em 1. 
NOTA: A divisão inteira também pode ser chamada floor division. Definitivamente, no futuro, deparar-se-á com este termo. 
Também é possível realizar operações matemáticas diretamente nos valores variáveis; 
compras_balas = 10 
municao_achada = 0 
quantidade_balas = 30 
nova_quantidade_balas = quantidade_balas + compras_balas + municao_achada 
quantidade_balas = nova_quantidade_balas 
 
tiro_arma_um = 1 
tiro_arma_dois = 5 
tiro_arma_tres = 10 
 
arma = tiro_arma_dois 
 
nova_quantidade_balas = quantidade_balas – arma 
 
Nesse caso, criamos uma variável compra_balas, que representa se o jogador comprou alguma bala e aqui foi armazenado 
o valor de 10, para representar que ele comprou 10 unidades de balas. Em seguida criamos uma variável municao_achada, 
que representa se nas explorações o jogador achou alguma bala guardada nos ambientes explorados, no caso foi armazenado o valor 
0, que significa que não foi achado nenhuma bala. E declaramos a quantidade_balas, que é a quantidade de balas que o 
jogador já possuía, antes da compra e antes de achar alguma bala. Agora declaramos a variável nova_quantidade_balas 
que é a soma das variáveis quantidade_balas, compras_balas e municao_achada. Neste ponto ele soma o 
que o jogador tem, com o que ele comprou e om as munições que ele achou. Na próxima linha eu carrego o valor da 
nova_quantidade_balas, para a quantidade_balas, o que carregara um novo valor as quantidades de balas que o 
jogador tem, no caso o novo valor será 40. Nesse ponto eu declaro as variáveis tiro_arma_um e atribuo o valor 1, o que significa 
que a cada tiro a arma só envia uma bala; tiro_arma_dois e atribuo o valor 5, o que significa que a cada tiro a arma só envia 
cinco balas de cada vez; tiro_arma_três e atribuo o valor 10, o que significa que a cada tiro a arma envia dez balas por cada 
tiro. Agora nesse ponto declaro a variável arma e atribuo o tipo de arma do jogador, no caso tiro_arma_dois, dizendo que a 
cada tiro são 5 balas que devem serem descontadas do valor das balas que tenho. E por fim eu dou um tiro, e a variável da 
nova_quantidade_balas vai assubir o valor da quantidade_balas menos o valor da variável arma, resultando 
um valor: qual valor seria esse? Talvez seja um pouco mais difícil de entender, mas a cada vez que vamos progredindo nos comandos 
e nos operadores a tendencia é ficar um pouco mais difícil, mas não se assuste, à medida que for progredindo iremos aumentando o 
nosso nível de conhecimento e as coisas vão se ajustando. 
Mas podemos melhorar o que foi feito acima, lembrem-se, sempre podemos melhoras então vamos entender só uma coisa: 
É POSSIVEL MODIFICAR UM DADO DE UMA VARIÁVEL A PARTIR DELE MESMO. DESSA 
FORMA, USAREMOS O SEU VALOR, E FAREMOS UMA RETROALIMENTAÇÃO, MODIFICANDO-O, 
SEM CRIAR UMA NOVA VARIÁVEL. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[43] 
Exemplo simples de x e y 
X = 2 
y = 2 
x = x + 2 
y = x + 2 
 
Entendendo: nas linhas 1 e 2 são criadas as variáveis x e y, e atribuímos o valor 2 para x e 2 para y. Na linha 3, a instrução x = x + 
2, atualiza o valor da variável x, somando o valor atual ao número 2, resultando no novo valor para a variável x igual a 4. Na linha 4 a 
variável y é atribuído o novo valor de x, que é 4, e soma 2 ao valor da variável o que resulta o valor de 6 para a variável y. 
NOTA: atribuir a mesma variável com o novo valor retirado da própria variável, somado com 2. Ao ver um registo como este, 
um matemático provavelmente protestaria - nenhum valor pode ser igual a si mesmo mais dois. Isto é uma contradição. Mas 
o Python trata o sinal = não como igual a, mas como atribuir um valor. E o descreveria como, tomo o valor atual de x, adicione 
2 e armazene o resultado em x. na verdade o valor da variável x foi incrementado por dois, o que nada tem a ver com uma 
comparação da variável com qualquer valor. 
Agora vamos implementar o nosso programinha e vamos reescrevê-lo. 
compras_balas = 1000 
municao_achada = 300 
quantidade_balas = 237 
quantidade_balas = quantidade_balas + compras_balas + municao_achada 
tiro_arma_um = 1 
tiro_arma_dois = 5 
tiro_arma_tres = 10 
arma = tiro_arma_dois 
quantidade_balas = quantidade_balas – arma 
Quantas Balas a variável quantidade_balas tem armazenada? 
Agora imaginemos que jogamos duas partidas consecutivas do nosso jogo, e gostaríamos de saber a quantidade média de disparos, 
veja o código e se consegue prever a média? 
total_disparos_partida_um = 1000 
total_disparos_partida_dois = 500 ? 
media = total_disparos_partida_um + total_disparos_partida_dois/2 
Qual o resultado da conta? 
Obviamente você deve ter chegado ao resultado de: 1.250, já que a média foi calculada errada, podemos corrigir usando parênteses 
(), como na matemática tradicional, podemos usar recursos e dividir cada valor por 2 ,a que: 
𝑀𝑀é𝑑𝑑𝑑𝑑𝑑𝑑 = 
𝑑𝑑 + 𝑏𝑏
2 = 
𝑑𝑑
2 + 
𝑏𝑏
2 = (𝑑𝑑 + 𝑏𝑏)/2 
Poderíamos fazer assim o código 
total_disparos_partida_um = 1000 
total_disparos_partida_dois = 500 
media = total_disparos_partida_um/2 + total_disparos_partida_dois/2 
NOTA: Na matemática devemos resolver divisão e multiplicação na ordem em que 
Consegue prever os valores de x e y? 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[44] 
aparecerem, soma e subtração na ordem em que aparecerem. Antes 
resolvemos na ordem parênteses, colchetes e chaves. 
Mas e se fosse de 10 partidas? 
𝑀𝑀é𝑑𝑑𝑑𝑑𝑑𝑑 = 
𝑑𝑑 + 𝑏𝑏 + 𝑐𝑐 + 𝑑𝑑 + 𝑒𝑒 + 𝑓𝑓 + 𝑔𝑔 + ℎ + 𝑑𝑑 + 𝑗𝑗
10 = 
𝑑𝑑
10 + 
𝑏𝑏
10 +
𝑐𝑐
10 +
𝑑𝑑
10 +
𝑒𝑒
10 +
𝑓𝑓
10 +
𝑔𝑔
10 +
ℎ
10 +
𝑑𝑑
10 +
𝑗𝑗
10 
 = (𝑑𝑑 + 𝑏𝑏 + 𝑐𝑐 + 𝑑𝑑 + 𝑒𝑒 + 𝑓𝑓 + 𝑔𝑔 + ℎ + 𝑑𝑑 + 𝑗𝑗)/10Daria muito trabalho então o melhor mesmo é, no caso da média de duas partidas: 
total_disparos_partida_um = 1000 
total_disparos_partida_dois = 500 
media = (total_disparos_partida_um + total_disparos_partida_dois)/2 
Operadores e suas ligações 
A ligação do operador determina a ordem dos cálculos efetuados por alguns operadores com igual prioridade, colocados lado a 
lado numa só expressão. A maioria dos operadores de Python têm ligação do lado esquerdo, o que significa que o cálculo da expressão 
é realizado da esquerda para a direita. Este exemplo simples mostrar-lhe-á como funciona. Veja: 
print(9 % 6 % 2) 
Há duas formas possíveis de avaliar esta expressão: 
• da esquerda para a direita: primeiro 9 % 6 dá 3 e, em seguida, 3 % 2 dá 1; 
• da direita para a esquerda: primeiro 6 % 2 dá 0 e, em seguida, 9 % 0 causa um erro fatal. 
Execute o exemplo e veja o que obtém. O resultado deve ser 1. Este operador tem ligação do lado esquerdo. Mas há uma exceção 
interessante. 
Lista de prioridades: 
Prioridade Operador 
1 +, - 
unário 2 ** 
3 *, /, //, % 
4 +, - 
Binário 5 , >= 
6 ==, !== 
TABELA10 -TABELA DE PRIORIDADES COMPLETA 
Operadores de parêntesis 
Claro, é sempre permitido utilizar parêntesis, o que pode alterar a ordem natural de um cálculo. De acordo com as regras 
aritméticas, as subexpressões entre parêntesis são sempre calculadas em primeiro lugar. Pode-se usar tantos parêntesis 
quantos forem necessários, e são frequentemente usados para melhorar a legibilidade de uma expressão, mesmo que não alterem a 
ordem das operações. 
Um exemplo de uma expressão com vários parêntesis é este: 
print((5 * ((25 % 13) + 100) / (2 * 13)) // 2) 
Tente calcular o valor que é impresso para a consola. Qual é o resultado da função print() ? R=10.0 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[45] 
Operadores de atalho 
Muito frequentemente usado, os operadores de atalho são usados quando queremos utilizar uma e a mesma variável tanto para o 
lado direito como para o esquerdo do = operador. Por exemplo, se precisarmos de calcular uma série de valores sucessivos de potências 
de 2, podemos utilizar uma peça como esta: x = x * 2 
Pode usar uma expressão como está se não conseguir adormecer e estiver a tentar lidar com ela usando alguns métodos bons e 
antiquados: 
sheep = sheep + 1 
O Python oferece-lhe uma forma abreviada de escrever operações como estas, que podem ser codificadas como se segue: 
x *= 2 
sheep += 1 
Vamos tentar apresentar uma descrição geral para estas operações. Se op é um operador de dois argumentos (esta é uma 
condição muito importante) e o operador é utilizado no seguinte contexto: 
variable = variable op expression 
Pode ser simplificado e mostrado da seguinte forma: 
variable op= expression 
Dê uma vista de olhos nos exemplos abaixo. Certifique-se de que os compreende a todos. 
i = i + 2 * j ⇒ i += 2 * j 
var = var / 2 ⇒ var /= 2 
rem = rem % 10 ⇒ rem %= 10 
j = j - (i + var + rem) ⇒ j -= (i + var + rem) 
x = x ** 2 ⇒ x **= 2 
TABELA11 -TABELA DE OPERAÇÕES DE ATALHOS 
2.2.11 Armazenamento das variáveis no computador 
Onde as nossas variáveis são armazenadas? Na RAM (Random-access Memory) é aqui que elas são armazenadas. As memórias 
RAM têm um tamanho, Módulos de até 128 GB de Memória RAM DDR 4 e DDR 5 já estão disponíveis no mercado, em ambientes de 
servidores que existem módulos especiais de até 512 GB. E quanto maior a memória RAM , maior a capacidade de armazenamento das 
variáveis, consequentemente mais programas simultâneos poderão ser executados, com a menor perda de performance. Todas as 
vezes que uma variável é criada, um pequeno espaço de RAM é ocupado com o seu valor, isso para qualquer programa seja um 
navegador, jogo, editores de texto etc. todos usam variáveis que vão consumindo a RAM. A Fig. 19 é um infográfico simplificado da RAM. 
Dificilmente nos preocupamos com o consumo de RAM por um programa que desenvolvemos, atualmente é muito difícil de se 
encontrar computadores com menos de 4 GB de RAM. Analogicamente uma gota numa piscina olímpica é uma variável para uma 
memória, além disso o sistema sabe o que fazer quando a memória está totalmente ocupada. Agora para quem vai criar aplicações em 
microcontroladores, como o Arduino, então deve-se otimizar a escrita do código, reaproveitando ao máximo as variáveis, pois a RAM 
nesses dispositivos embarcados é bastante limitada. 
 
 
 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[46] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2.2.12 Os erros mais comuns 
Erros frequentemente acontecem durando a criação de um programa, muitos dele são relacionados a variáveis e aqui será listado 
os mais comuns: 
Não utilizar aspas na declaração de uma String. Em alguns casos o programador esquece de utilizar aspas 
Código com problema: 
saudacao = "Olá mundo 
Código corrigido: Diferente de outras variáveis, o conteúdo das Strings precisa estar entre aspas. 
saudacao = "Olá mundo" 
Utilização de variável não declarada. Somente é possível utilizar uma variável após ela ter sido declarada. 
Código com problema: 
saudacao = nova_saudacao 
Código corrigido: 
nova_saudacao = "Olá mundo no Python" 
saudacao = nova_saudacao 
Declarar uma variável com duas igualdades. A declaração de uma variável é feita utilizando apenas um sinal de igualdade. 
MEMÓRIA RAM 
 
ENDEREÇO CONTEÚDO 
0 x 00056A 2 
0 x 000573 ... 
0 x 00057F ... 
0 x 000583 ... 
0 x 0005FF “Olá mundo” 
Código de 
programação 
 
 
 
numero = 2 
 
 
 
Texto = “Olá mundo” 
FIG. 19 – REPRESENTAÇÃO SIMPLIFICADA DA MEMÓRIA RAM 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[47] 
Código com problema: 
saudacao == "Olá mundo" 
Código corrigido: 
saudacao = "Olá mundo" 
Escrita incorreta das variáveis booleanas. As variáveis booleanas podem assumir dois valores: True ou False, que devem ser 
escritos desta forma. 
Código com problema: 
variabel_booleana = true 
outra_variavel_booleana = "True" 
Código corrigido: 
variabel_booleana = True 
outra_variavel_booleana = True 
Utilizar vírgula para separar casas decimais. A separação de casas decimais segue o formato americano onde utiliza-
se (.) ponto em vez de vírgula. 
Código com problema: 
salario = 100,5 
Código corrigido: 
salario = 100.5 
2.3 Algumas funções no Python 
2.3.1 print() 
linha de comando: 
print (“Olá, mundo!”) 
A palavra print, que aqui é o nome da função, onde quer que ela apareça sempre será o nome de uma função. Uma função no Pythone 
é uma parte separada do código do computador capaz de: 
• Causar um efeito qualquer: enviar um texto para o terminal, criar um arquivo, desenhar uma imagem etc. 
• Avaliar um valor: a raiz quadrada de um valor ou comprimento do texto e devolvê-lo como resultado da função. 
É POSSIVEL QUE MUITAS FUNÇÕES NO PYTHON FAÇAM AS SUAS COISAS JUNTAMENTE. 
De onde vem as funções? 
• Podem vir do próprio Python; a função print é uma deste tipo; tal função é um valor acrescentado recebido 
juntamente com o Python e o seu ambiente (é incorporada); não é necessário fazer nada de especial (por exemplo, 
perguntar a alguém por qualquer coisa) se quiser fazer uso dela; 
• Podem ser provenientes de um ou mais dos add-ons de Python chamados módulos; alguns dos módulos vêm com 
Python, outros podem requerer instalação separada - seja qual for o caso, todos eles precisam de estar 
explicitamente ligados ao seu código (mostrar-lhe-emos como fazê-lo em breve); 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[48] 
• pode escrevê-los você mesmo, colocando tantas funções quantas quiser e precisar dentro do seu programa para o 
tornar mais simples, mais claro e mais elegante. 
O nome da função deve ser significativo, como no caso print que se percebe por si só o que ele faz, 
 
Toda função pode ter: 
Uma função também pode ter uma componente muito importante para a função 
Funções em Python, por outro lado, sãomais versáteis, e dependendo das necessidades individuais, também podem aceitar qualquer 
número de argumentos - tantos quantos forem necessários para desempenhar as atividades desejadas. 
NOTA: qualquer número inclui zero - algumas funções de Python não precisam de qualquer argumento. 
print (“Olá, mundo!”) 
Apesar do número de argumentos necessários/fornecidos, as funções em Python exigem fortemente a presença de um par de 
parênteses. Se quiser entregar um ou mais argumentos a uma função, coloque-os dentro dos parêntesis. Se for utilizar uma função que 
não aceita qualquer argumento, ainda assim tem de ter os parêntesis. 
NOTA: para distinguir palavras comuns de nomes de funções, coloque um par de parêntesis vazios após os seus nomes, mesmo 
que a função correspondente queira um ou mais argumentos. Esta é uma convenção padrão. 
A função de que estamos a falar aqui é print(). 
A função print() no nosso exemplo tem algum argumento? 
Claro que sim, mas o que são eles? 
Na função Print do comando acima, o único argumento é uma String “Olá, mundo!” 
Como já vimos reiteradamente, uma String sempre vem delimitada com aspas, que cortam uma parte do código e atribuem-lhe um 
significado diferente. Imaginemos que as aspas dizem algo como: o texto entre nós não é código. Não se destina a ser executado, e deve 
tomá-lo como está. Quase tudo colocado entre aspas será tomado literalmente, não como código, mas como dados. 
O nome da função (print neste caso) juntamente com os parêntesis e argumentos, formam a invocação da função. 
O que acontece quando o Python encontra uma invocação como a apresentada a seguir? 
function_name(argument) 
• primeiro, o Python verifica se o nome especificado é legal (navega nos seus dados internos a fim de encontrar uma função 
existente com o mesmo nome; se esta pesquisa falhar, o Python aborta o código); 
• segundo, o Python verifica se os requisitos da função para o número de argumentos lhe permitem invocar a função desta 
forma (por exemplo, se uma função específica exigir exatamente dois argumentos, qualquer invocação que apresente 
apenas um argumento será considerada errada, e abortará a execução do código); 
• terceiro, o Python deixa o seu código por um momento e salta para a função que pretende invocar; claro, também leva 
seus argumentos e os passa para a função; 
• quarto, a função executa o seu código, causa o efeito desejado (se houver um), avalia o resultado desejado (se existir) e 
termina a sua tarefa; 
• finalmente, o Python regressa ao seu código (ao local imediatamente após a invocação) e retoma a sua execução. 
Três questões importantes têm de ser respondidas assim que possível: 
UMA CAUSA UM EFEITO 
ARGUMENTOS, 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[49] 
1. Qual é o efeito que a função print() causa? 
O efeito é muito útil e muito espetacular. A função: 
• toma os seus argumentos (pode aceitar mais do que um argumento e pode também aceitar menos do que um argumento) 
• converte-os numa forma legível para o ser humano, se necessário (como pode suspeitar, as strings não requerem esta 
ação, uma vez que a string já é legível) 
• e envia os dados resultantes para o dispositivo de output (normalmente a console); por outras palavras, qualquer coisa 
que coloque na função print() aparecerá no ecrã. 
Não admira, então, que a partir de agora utilize print() muito intensivamente para ver os resultados das suas operações e 
avaliações. 
2. Que argumentos print() espera? 
Qualquer argumento. O print() é capaz de operar com virtualmente todos os tipos de dados oferecidos pelo Python. Strings, 
números, caráteres, valores lógicos, objetos - qualquer um destes pode ser passado com sucesso para print(). 
3. Que valor é devolvido pela função print() ? 
Nenhum. O seu efeito é suficiente. 
Um programa de computador que contém uma invocação de função. Uma invocação de função é um dos muitos tipos possíveis de 
instruções Python. Qualquer programa complexo contém geralmente muito mais instruções do que uma. A questão é: como se acoplam 
mais do que uma instrução no código Python? A sintaxe de Python é bastante específica nesta área. Ao contrário da maioria das 
linguagens de programação, o Python requer que não haja mais do que uma instrução numa linha. A linha pode estar vazia (ou seja, 
pode não conter qualquer instrução) mas não deve conter duas, três ou mais instruções. Isto é estritamente proibido. 
 
Nota: o Python faz uma exceção a esta regra - permite que uma instrução se espalhe por mais do que uma linha (o que pode ser 
útil quando o seu código contém construções complexas). 
 
Vamos expandir um pouco o código, pode vê-lo no editor. Execute-o e anote o que vê na consola. 
 
A sua console Python deve agora ter este aspeto: 
 
print("The itsy bitsy spider climbed up the waterspout.") 
print("Down came the rain and washed the spider out.") 
 
The itsy bitsy spider climbed up the waterspout. 
Down came the rain and washed the spider out. 
 
 
 
Observações: 
 
• O programa invoca a função print() duas vezes, e pode ver duas linhas separadas na console - isto significa que 
print() começa o seu output a partir de uma nova linha cada vez que inicia a sua execução; pode alterar este 
comportamento, mas também pode utilizá-lo em seu proveito; 
• cada invocação print() contém uma String diferente, uma vez que o seu argumento e o conteúdo da consola a refletem 
- isto significa que as instruções no código são executadas pela mesma ordem em que foram colocadas no source file 
(Provando que o computador lê da esquerda para a direita e de cima para baixo; nenhuma instrução seguinte é executada até 
que a anterior esteja concluída (há algumas exceções a esta regra, mas pode ignorá-las por agora). 
 
Acrescentámos uma invocação de função vazia print() . Chamamos-lhe vazia porque não apresentámos quaisquer 
argumentos para a função. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[50] 
print("A aranha pequenina subiu pela tromba d’agua.") 
print() 
print("A chuva que caiu veio e levou a aranha.") 
 
 
A Aranha pequenina subiu pela tromba d’agua. 
A invocação vazia print() não é tão vazia como se poderia esperar - produz uma linha vazia, ou (esta interpretação também é 
correta) o seu output é apenas uma newline. 
Esta não é a única forma de produzir uma newline na consola de output. Vamos agora mostrar-lhe outra forma. 
 
caráteres de escape e de newline 
Modificámos novamente o código. Olhe com atenção. Há duas mudanças muito subtis - inserimos um estranho par de carateres 
dentro da rima. Têm este aspeto: \n. Curiosamente, enquanto se pode ver dois caráteres, o Python vê um. 
 
A barra invertida (\) tem um significado muito especial quando usados dentro de uma String - a isto chama-se o caractere de 
escape. A palavra escape deve ser entendida especificamente - significa que a série de caráteres na String escapa por um momento 
(um momento muito curto) para introduzir uma inclusão especial. Por outras palavras, a barra invertida não significa nada em si, mas 
é apenas uma espécie de anúncio de que o próximo caractere após a barra invertida também tem um significado diferente. 
 
A letra n colocada após a barra invertida vem da palavra newline (nova linha). Tanto a barra invertida como o n formam um símbolo 
especial chamado um caratere de newline, que incita a consola a iniciar uma nova linha de output. 
Execute o código. A sua consola deve agora ter este aspeto: 
 
print("A aranha pequenina\n subiu pela tromba d’agua.") 
print() 
print("A chuva que caiu\n veio e levou a aranha.") 
 
 
A Aranha pequenina 
subiu pela tromba d’agua. 
 
A chuva que caia 
veio e levou a aranha. 
 
 
Esta convenção tem duas consequências importantes: 
 
1. Se quiser colocar apenas uma barra invertida dentro de uma String, não se esqueça da sua natureza de escape - tem de a 
duplicar, por exemplo, uma tal invocação causará um erro: 
 
print("\") 
 
enquanto esta não o fará: 
 
print("\\") 
 
2. Nemtodos os pares de escape (a barra invertida acoplada a outro caractere) significam algo. 
 
Olhe para a janela do editor. Isto é o que vamos testar agora: 
 
print("A aranhazinha","escalou" , "a tromba d’água.") 
 
Os argumentos são separados por vírgulas. Cercamo-los de espaços para os tornar mais visíveis, mas não é realmente 
necessário, e não o faremos mais. Neste caso, as vírgulas que separam os argumentos desempenham um papel completamente diferente 
da vírgula dentro da String. A primeira é uma parte da sintaxe de Python, a segunda destina-se a ser mostrada na consola. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[51] 
 
Se voltar a olhar para o código, verá que não há espaços dentro das Strings. 
 
A consola deve agora mostrar o seguinte texto: 
 
A Aranhazinha escalou a tromba d’água. 
Duas conclusões emergem deste exemplo: 
 
• a função print() invocada com mais do que um argumento faz output de todos eles numa só linha; 
• a função print() coloca um espaço entre os argumentos de output, por sua própria iniciativa. 
Argumentos de Keyword 
O Python oferece outro mecanismo para a passagem de argumentos, que pode ser útil quando se quer convencer a função 
print() a alterar um pouco o seu comportamento. O mecanismo é chamado argumentos de keyword. O nome deriva do facto de 
o significado destes argumentos ser retirado não da sua localização (posição) mas da palavra especial (keyword) utilizada para os 
identificar. A função print() tem dois argumentos de keyword que pode usar para os seus propósitos. O primeiro deles é 
nomeado end. 
• um argumento de keyword consiste em três elementos: uma keyword identificando o argumento (end aqui); um sinal de 
igual (=); e um valor atribuído a esse argumento; 
• qualquer argumento de keyword deve ser colocado após o último argumento posicional (isto é muito importante) 
No nosso exemplo, fizemos uso do end argumento de keyword, e o definimos para uma String contendo um espaço. 
Execute o código para ver como ele funciona. 
print("My name is", "Python.", end=" ") 
print("Monty Python.") 
A consola deve agora mostrar o seguinte texto: 
 
My name is Python. Monty Python. 
 
 
Por padrão a função print() tem um \n oculto, a keyword end apenas anula o \n oculto, e joga o conteúdo do próximo 
comando print, logo ao lado no final do argumento. Como pode ver, o argumento de keyword end determina os caracteres que a função 
print() envia para o output, uma vez que atinge o final dos seus argumentos posicionais. 
O comportamento padrão reflete a situação em que o argumento de keyword end é implicitamente usado da seguinte 
maneira: end="\n". Quando usamos o argumento end=””(sem espaço)ou seja com nenhum argumento, ela não produzirá 
nenhuma saída, uma vez que os argumentos posicionais foram esgotados. 
NOTA: não foram enviadas newlines para o output. A string atribuída ao argumento de keyword end pode ter qualquer 
comprimento. Experimente-a se quiser. 
Também temos o argumento de keyword chamado de sep (como separador) 
print("My", "name", "is", "Monty", "Python.", sep="-") 
 
My-name-is-Python-Monty-Python. 
 
A função print() preenche entre cada String com o que estiver na varial sep, no caso um traço (-). Podemos usar os dois 
argumentos numa só função, por exemplo: 
print("My", "name", "is", sep="_", end="_") 
print("Monty", "Python." ", sep="*", end="_") 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[52] 
Qual seria o resultado? 
NOTA: Podemos duplicar uma String apenas multiplicando por 2, exemplo: print("Lindo! "*2) 
Lindo! Lindo! 
2.3.1.1 Deixar comentários em código: por quê? como? e quando? 
Colocar algumas palavras dirigidas não ao Python, mas aos humanos, normalmente para explicar a outros leitores do código como 
funcionam os truques utilizados no código, ou os significados das variáveis, e para manter a informação armazenada sobre quem é o 
autor e quando o programa foi escrito. Uma observação inserida no programa, que é omitida em runtime, é chamada um comentário. 
Como se deixa este tipo de comentário no source code? Tem de ser feito de uma forma que não force o Python a interpretá-lo como 
parte do código. 
Sempre que o Python encontra um comentário no seu programa, o comentário é completamente transparente para ele - do ponto 
de vista de programação Python, este é apenas um espaço (independentemente da duração do comentário real). Em Python, um 
comentário é um pedaço de texto que começa com um sinal # (cardinal, ou hash em inglês) e se estende até ao final da linha. Se quiser 
um comentário que abranja várias linhas, tem de colocar um hash à frente de todas elas. 
Tal como aqui: 
# Este programa calcula a hipotenusa c. 
# a e b são o tamanho dos catetos. 
a = 3.0 
b = 4.0 
c = (a ** 2 + b ** 2) ** 0.5 # usamos ** ao inves de raiz quadrada. 
print("c =", c) 
 
Programadores bons e responsáveis descrevem cada peça de código importante, por exemplo, explicando o papel das variáveis; 
embora deva ser declarado que a melhor maneira de comentar as variáveis é nomeá-las de uma forma inequívoca. Por exemplo, se uma 
determinada variável for concebida para armazenar uma área de algum quadrado único, o nome area_quadrada será obviamente 
melhor do que tia_jane. Dizemos que o primeiro nome é self-commenting (autocomenta-se). 
 
Os comentários podem ser úteis noutro aspeto - pode utilizá-los para marcar um pedaço de código que atualmente não é necessário 
por qualquer razão. Veja o exemplo abaixo, se removermos o comentário da linha realçada, isto afetará o output do código: 
 
# This is a test program. 
x = 1 
y = 2 
# y = y + x 
print(x + y) 
 
Isto é frequentemente feito durante os testes de um programa, a fim de isolar o local onde um erro possa estar escondido. 
 
SUGESTÃO: Se quiser comentar ou descomentar rapidamente várias linhas de código, selecione a(s) linha(s) que deseja modificar 
e use o seguinte atalho de teclado: CTRL + / (Windows) ou CMD + / (Mac OS). É um truque muito útil. 
2.3.2 Input() 
A tecla programável input() é uma função que habilita a leitura de entrada de dados pelo usuário, retornando o mesmo dado 
para ser executado pelo programa. O programa pode manipular os dados, tornando o código genuinamente interativo. Até então, os 
programas eram programas de uma 
única solução, com a função input() 
iremos ter variáveis entradas pelo 
usuário, o que fará mais sentido o 
programa. Virtualmente todos os 
programas leem e processam dados. Um programa que não recebe um entrada do utilizador é analogamente um programa surdo, tal 
qual um programa que não mostra o resultado calculado é um programa cego. Dê uma vista de olhos no nosso exemplo: 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[53] 
 
print("diga alguma coisa") 
anything = input() 
print("Hmm...", anything, "... sério?") 
 
 
 
Nota: 
• O programa pede ao utilizador que introduza alguns dados na console (muito provavelmente utilizando um teclado, 
embora também seja possível introduzir dados utilizando voz ou imagem); 
• a função input() é invocada sem argumentos (esta é a forma mais simples de usar a função); a função irá mudar a 
console para o modo de input; verá um cursor a piscar, e poderá introduzir algumas teclas, terminando com a tecla Enter; 
todos os dados introduzidos serão enviados para o seu programa através do resultado da função; 
• nota: é necessário atribuir o resultado a uma variável; isto é crucial - a falta desta etapa fará com que os dados introduzidos 
se percam; 
• então, utilizamos a função print() para fazer output dos dados que obtemos, com algumas observações adicionais. 
A função input() com um argumento 
A função input() pode fazer algo mais: pode incitar o utilizador sem qualquer ajuda de print(). Modificámos um pouco 
o nosso exemplo, olha para o código: 
 
anything = input("diga alguma coisa...") 
print("Hmm...", anything, "...Sério?") 
 
Nota: 
• a keyword input() é invocada com um argumento - é uma String contendo uma mensagem;Estruturada 
Prof.: André Andrade 
 
[3] 
EM WINDOWS.......................................................................................................................................................................................................................17 
EM LINUX ............................................................................................................................................................................................................................ 20 
Debian e Ubuntu ............................................................................................................................................................................................................ 20 
RedHat e CentOS .......................................................................................................................................................................................................... 20 
Instalação por repositório ...................................................................................................................................................................................... 20 
EM Mac OS X ..................................................................................................................................................................................................................... 20 
Instalação do zero ........................................................................................................................................................................................................ 21 
Escrevendo um programa: ...................................................................................................................................................................................... 22 
Como estragar e corrigir o seu código ............................................................................................................................................................ 23 
2. Operadores, expressões e variáveis ............................................................................................................................................................... 28 
Entender corretamente o problema que será trabalhado é fundamental para construir uma solução adequada. Infelizmente, 
muitos aprendizes falham nessa etapa e como consequência criam programas incorretos. Felizmente, existem estratégias que 
ajudam na resolução de problemas. ................................................................................................................................................................................. 28 
Literal ................................................................................................................................................................................................................................. 39 
Inteiros ............................................................................................................................................................................................................................... 39 
Números octais e hexadecimais ................................................................................................................................................................................ 40 
Floats .................................................................................................................................................................................................................................. 40 
Codificação de floats ...................................................................................................................................................................................................... 41 
Operadores e suas ligações ....................................................................................................................................................................................... 44 
Lista de prioridades: ...................................................................................................................................................................................................... 44 
Operadores de parêntesis ........................................................................................................................................................................................... 44 
Operadores de atalho.................................................................................................................................................................................................... 45 
carateres de escape e de newline ............................................................................................................................................................................ 50 
Argumentos de Keyword ............................................................................................................................................................................................... 51 
A função input() com um argumento ....................................................................................................................................................................... 53 
Type casting...................................................................................................................................................................................................................... 53 
Conversão de tipo: str() ............................................................................................................................................................................................... 54 
Exercício 3 ............................................................................................................................................................... Erro! Indicador não definido. 
Qual é o output do seguinte snippet?....................................................................................................................................................................... 64 
print((2 % -4), (2 % 4), (2 ** 3 ** 2)) .................................................................................................................................................................... 64 
R: -2 2 512 ................................................................................................................................................................... Erro! Indicador não definido. 
Exercício 6 ................................................................................................................................................................. Erro! Indicador não definido. 
Código: ................................................................................................................................................................................................................................ 65 
resposta...................................................................................................................................................................... Erro! Indicador não definido. 
exercício 7.................................................................................................................................................................. Erro! Indicador não definido. 
Veja o código no editor: ele lê um valor float , coloca-o numa variável chamada x, e imprime o valor de uma variável 
chamada y. A sua tarefa é completar o código para avaliar a seguinte polinômio: ........................................................................................ 65 
3x3-2x2+3x-1 ....................................................................................................................................................................................................... 65 
O resultado deve ser atribuído a y. .........................................................................................................................................................................• a mensagem será exibida na consola antes de ser dada ao utilizador a oportunidade de introduzir qualquer coisa; 
• input() fará então o seu trabalho. 
Esta variante da invocação input() simplifica o código e torna-o mais claro. o resultado da função input() é uma String 
contendo todos os caracteres que o utilizador introduz a partir do teclado. Não é um inteiro ou um float, o que significa que não deve 
usá-la como um argumento de qualquer operação aritmética, por exemplo, não pode usar estes dados para os elevar ao quadrado, 
dividi-los por qualquer coisa, ou dividir qualquer coisa por eles. 
 
anything = input("Enter a number: ") 
something = anything ** 2.0 
print(anything, "to the power of 2 is", something) 
 
 
O que acontece? O Python deve ter dado o seguinte output: 
 
Enter a number: 2 
Traceback (most recent call last): 
 File "main.py", line 4, in 
 something = anything ** 2.0 
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'float' 
 
A última linha da frase explica tudo - tentou aplicar o operador ** para 'str' (String) acompanhado com 'float' e Isto é proibido. Isto 
deve ser óbvio - pode prever o valor de "ser ou não ser" elevado à potência de 2? Não podemos! O Python também não pode. Mas, será 
que caímos num impasse? Existe uma solução para este problema? Claro que existe! 
 
Type casting 
O Python oferece duas funções simples para especificar um tipo de dados e resolver este problema - aqui estão elas: int() e 
float(). Os seus nomes são self-commenting: 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[54] 
 
• a função int() toma um argumento (por exemplo, uma string: int(string)) e tenta convertê-lo num inteiro; se 
falhar, todo o programa também falhará (há uma solução para esta situação, mas mostrar-lhe-emos isto um pouco mais 
tarde); 
• a função float() toma um argumento (por exemplo, uma string: float(string)) e tenta convertê-lo num float 
(o resto é o mesmo). 
Isto é muito simples e muito eficaz. Além disso, pode invocar qualquer uma das funções, passando os input() resultados 
diretamente para elas. Não há necessidade de utilizar qualquer variável como armazenamento intermédio. Implementámos a ideia no 
editor - dê uma vista de olhos ao código. 
 
anything = float(input("Enter a number: ")) 
something = anything ** 2.0 
print(anything, "to the power of 2 is", something) 
 
Pode imaginar como flui a String introduzida pelo utilizador a partir de input() para print()? Tente executar o código 
modificado. Não se esqueça de introduzir um número válido e verifique alguns valores diferentes, pequenos e grandes, negativos e 
positivos. Zero é também um bom input. 
Ter uma equipa composta pelo trio input()-int()-float() abre muitas novas possibilidades. Acabará por ser capaz 
de escrever programas completos, aceitando dados sob a forma de números, processando-os e exibindo os resultados. É claro que 
estes programas serão muito primitivos e pouco utilizáveis, uma vez que não podem tomar decisões, e consequentemente não são 
capazes de reagir de forma diferente a diferentes situações. No entanto, isto não é realmente um problema; vamos mostrar-lhe como 
ultrapassá-lo em breve. O nosso próximo exemplo refere-se ao programa anterior para encontrar o comprimento de uma hipotenusa. 
Vamos reescrevê-lo e torná-lo capaz de ler o comprimento das pernas a partir da console. 
 
cat_a = float(input("Entrar o cateto: ")) 
cat_b = float(input("Entrar o cateto oposto: ")) 
hypo = (cat_a**2 + cat_b**2) ** .5 
print("O tamanho da hipotenusa é", hypo) 
 
Veja acima o programa- é este o aspeto que tem agora. O programa pede duas vezes ao utilizador o comprimento de ambos os 
catetos, avalia a hipotenusa e imprime o resultado. Execute-o e tente introduzir alguns valores negativos. O programa - infelizmente - 
não reage a este erro óbvio. Vamos ignorar esta fraqueza por agora. Voltaremos a este assunto em breve. Note que no programa que 
pode ver no editor, a variável hypo é utilizada apenas para uma única finalidade - para guardar o valor calculado entre a execução da 
linha de código adjacente. Como a função print() aceita uma expressão como seu argumento, pode remover a variável do código. 
Tal como isto: 
 
cat_a = float(input("Entrar o cateto: ")) 
cat_b = float(input("Entrar o cateto oposto: ")) 
print("O tamanho da hipotenusa é", (cat_a**2 + cat_b**2)**.5 
 
Conversão de tipo: str() 
Já sabe como utilizar as funções int() e float() para converter uma String num número. Este tipo de conversão não é 
uma via de mão única. Também se pode converter um número numa String, o que é muito mais fácil e seguro - esta operação é sempre 
possível. Uma função capaz de o fazer chama-se str(): 
 
str(numero) 
 
Para ser honesto, pode fazer muito mais do que apenas transformar números em Strings, 
 
O “triângulo de ângulo retângulo” novamente. Aqui está o nosso programa “triângulo de ângulo retângulo” novamente: 
 
cat_a = float(input("Entrar o cateto: ")) 
cat_b = float(input("Entrar o cateto oposto: ")) 
print("O tamanho da hipotenusa é " + str((cat_a**2 + cat_b**2)**.5)) 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[55] 
 
Modificámo-lo um pouco para lhe mostrar como a função str() funciona. Graças a isso, podemos passar todo o resultado para 
a função print() como uma String, esquecendo as vírgulas. 
 
 Até aqui demos alguns passos sérios no seu caminho para a programação em Python. Já conhece os tipos de dados básicos, e um 
conjunto de operadores fundamentais. Sabe como organizar o output e como obter dados do utilizador. Estas são bases muito 
importantes para os próximos Módulos. 
2.4 Por que precisamos de entrada e saída de dados? 
Agora que já entendemos de variáveis, é hora de avançar nos conceitos de entradas e saídas. 
#Programa Soma 
numero_um=5 
numero_dois=10 
resultado_soma=numero_um+numero_dois 
Ao executarmos o algoritmo Programa Soma, o valor armazenado na variável resultado_soma será 15. Isso acontece, pois 
os dados guardados nas variáveis numero_um e numero_dois não irão se alterar, no entanto, no mundo real, os valores são 
informados elo usuário da aplicação, e pode ser alterado para fornecer outros resultados. A princípio pode parecer meio inútil um 
programa que uma variável é constante e que é engessado. Mas é um excelente recurso didático para mostrar que a limitação de nosso 
código gera uma inquietude, e nos faz pensar... “Esse ao invés de entrar um número fixo no programa, eu pedisse para o usuário que 
escolhesse? É possível? Como fazer? E Qual a utilidade? Vimos a função input(), e já sabemos que é possível! 
Ao utilizar o comando input() estamos interagindo com a sua interface gráfica que é formada por botões, espaços para digitar 
textos, ícones, entre outros. Por trás de tudo isso está o que chamamos de código-fonte, que são as instruções de programação a que 
apenas a empresa WhatsApp possui acesso. Assim, podemos pensar em nossos programas como uma estrutura em duas camadas: 
interface e código, como ilustrado na figura a seguir. 
 
 
 
 
 
As entradas seguem o fluxo interface código, isso faz muito sentido, pois os recursos de entradas são interfaces como (mouses, 
teclados, botões, campos de texto e outros, e as saídas fazem o caminho oposto, do código  interface. Já que quando um 
processamento é feito no código, sua resposta é apresentada na interface de vídeo. Assim, percebe-se que o usuário interage com a 
interface gráfica do aplicativo, que repassa essas ações para a camada de código, responsável por processá-las. Por sua vez, a resposta 
então é apresentada na interface. Por exemplo, no WhatsApp, ao escrever um texto e pressionar no botão de envio de mensagem (ações 
que ocorrem na interface do aplicativo), espera-se que ela seja enviada ao contato desejado (a partir de um processamento realizado 
pelo código). O resultado disso é uma resposta produzida pela aplicação, por exemplo, exibindo um ícone para indicar que a mensagem 
foi encaminhadaao destinatário. Nesse exemplo temos os dois procedimentos descritos anteriormente: entrada e saída. 
2.4.1 Entrada de dados 
Até o presente momento estávamos entrado dados da seguinte forma: variável = literal ou variável = floating ou variável = booleana 
ou ainda variável = String, também fizemos variável = função matemática agora vamos entrar em mais uma etapa onde variável = 
função do tipo: variável=input(), e de forma simples o nosso programa passa para outro patamar, o de interação com o usuário, já que 
como vimos, a função input() permite a entrada de dados, e agora a nossa variável é realmente variável, dependendo do programa e 
dependendo do que foi projetado a ser feito. Ex: 
nome=input() 
Interface 01 
02 Código 
FIG. 20 – EXEMPLO DE UMA ESTRUTURA DE DUAS CAMADAS, COM A DIREÇÃO DO FLUXO DE ENTRADA E SAÍDA. 
EN
TR
AD
AS
 
SA
ÍD
AS
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[56] 
Agora com esse código, o computador vai permitir que o utilizem o teclado, e tudo que for digitado até que pressionemos a tecla 
ENTER será armazenado na variável nome. No entanto, se nenhuma informação for digitada, o restante do algoritmo não será executado. 
Quando uma linha de instrução se depara com um input() a ser processado, o computador aguarda o usuário digitar algo e teclar ENTER. 
nome=input() 
saudacao= “Olá”+nome 
Quando executamos o código anterior, o computador vai parar até que o usuário 
entre com um dado, o cursor fica piscando esperando a entrada do usuário, e a 
operação de concatenação nunca será processada. Ao se digitar um nome por 
exemplo, e se pressionar ENTER, o computador vai prosseguir para a próxima 
instrução e vai armazenar na variável saudação o que foi olá com o que foi 
digitado. É possível termos uma, duas, centenas de variáveis inseridas no 
programa, tantos quanto necessitarmos. Ex.: 
numero_um=input() 
numero_dois=input() 
Ao executar o programa acima, aparecerá um cursor piscando, e o que inserir? 
Não existe uma informação que necessitamos que o usuário entre. A forma de 
filtrar o que o usuário vai entrar é ou usar um print(),como em: 
print(“Entrar o primeiro número:”) 
numero_um=input() 
print(“Entrar o segundo número:”) 
numero_dois=input() 
Outra forma mais elegante, que reduz o código seria, entrar o que se necessita 
dentro do input, como a seguir: 
numero_um=input(“Entrar o primeiro número:”) 
numero_dois=input(“Entrar o primeiro número:”) 
O resultado é o mesmo e o código reduziu pela metade. 
2.5 Tipos de conversão de dados 
Quando temos uma função com input(), ao usuário digitar qualquer coisa, seja um número, uma booleana, um floating ou mesmo 
String, sempre será armazenado como uma String. 
numero_um=input(“Entrar o primeiro número:”) 
Se por acaso o usuário entrar o número 7, a variável numero_um vai enterder que se recebeu um “7”. E já vimos que “7”7 
um é uma String o outro é um número literal. 
numero_um=input(“Entrar o primeiro número:”) 
numero_dois=input(“Entrar o primeiro número:”) 
resultado_soma=numero_um+numero_dois 
os dados são lidos no teclado e armazenados nas variáveis numero_um e numero_dois, imaginaremos que o usuário 
escolheu os números 4 e 6, o valor da variável resultado_soma, na verdade será um resultado de concatenação, já que ambos 
foram convertidos para String no ato de leitura do programa, e o resultado será o texto: “46”. Esse problema pode ser mais grave 
ao tentarmos realizar uma operação matemática em uma String. Como em: 
numero_um=input(“Entrar o primeiro número:”) 
subtração=numero_um-2 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[57] 
A execução do código produzirá um erro do tipo TypeError: unsupported operand type(s) for -: ‘str’ and ‘int’. Não se intimide com 
as informações que o computador vai lhe informar, não muito amigável, e que você pode realizar operações entre diferentes ti´pos de 
variáveis. Realmente não faz nenhum sentido subtrair azul de 2. Realizar operações matemáticas em números lidos é extremamente 
necessário para fazer os nossos códigos serem eficazes e fazerem sentido, e para isso é preciso converter a String recebida em um 
inteiro ou um floating. E perceberemos que da mais medo do que parece, já que é um procedimento muito simples, para isto usaremos 
os comandos int() para transformar em inteiro e um float() para transformar num número floating, um ponto flutuante com 
a possibilidades de ter a parte decimal. A sintax seria : variável inteira = int(variável a ser convertida), ou variável floating = 
float(variável a ser convertida). veja o funcionamento a seguir das instruções dentro dos parênteses, assim criamos uma variável para 
guardar o resultado desta conversão, que será um inteiro se for usando a função int e um decimal se usado o float. 
numero_string=input() 
numero_inteiro=int(numero_string) 
subtração=numero_inteiro-2 
Na linha 1 estamos lendo uma variável pelo teclado e será armazenada em numero_string, na sequencia é criada uma 
variável nomeada numero_inteiro, que armazenará o resultado da conversão de numero_string em inteiro, feito 
através da instrução int. agora podemos usar o numero_inteiro em operações matemáticas, e não mais teremos qualquer 
erro, já que a operação é legalizada pelo Python. 
Também é possível converter de números para String com o uso da instrução str. Essa conversão em particular pode parecer 
sem sentido, mas é muito útil. Pois com muita frequência precisaremos manipular números em nossos algoritmos, principalmente 
quando precisamos mostrar o resultado para o usuário na saída, essa informação será acompanhada de algum texto. Como não existe 
a possibilidade de se concatenar números com texto, convertê-los poderá ser bem útil. 
numero_um=int(input(“entrar o número um”)) 
numero_dois=int(input(“entrar o número dois”)) 
resultado_soma=str(numero_um+numero_dois) 
print(“O resultado da soma é: ”+resultado_soma_texto) 
Comando f-string 
Para combinarmos texto com variáveis de forma mais elegante, usamos as Strings literais formadas, também conhecidas como f-
string, a seguir temos um exemplo da sintaxe; 
nome=input(“Qual o seu nome? ”) 
print(f“Olá {nome}, seja bem vindo(a)”) 
Obs.: Esse é um tipo de comando que pode não rodar numa sandbox (interface Python online) embora é garantido que na PVM e na 
IDLE Shell irá rodar bem. 
Com a f-String, não é necessário concatenar basta referenciar variáveis e instruções diretamente em nossas Strings. Basta coloca-
las entre chaves ‘{}’ já que possibilita a exibição de textos e números, sem a necessidade de usar a função str(). 
numero=7 
print(f“Este é o número: {numero}”) 
Também podemos formatar a apresentação dos números durante a exibição em tela, como limitar a quantidade de dígitos a serem 
apresentados: 
pi=3.14115926535 
print(f“Este é o pi com 2 casas decimais: {pi:.2f}”) # 3.14 
print(f“Este é o pi com 5 casas decimais: {pi:.5f}”) # 3.14115 
2.6 Erros na programação 
Erros acontecem na programação com uma certa frequência. Os iniciantes vivenciam essa experiência de diferentes formas. Alguns 
podem se frustrar, e perder o caminho pra a solução. Outros chegam ao estremo de desistirem, enquanto outros vão compreender que 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[58] 
a existência do erro é parte do processo de aprendizagem e utilizarão esse conhecimento para aperfeiçoar suas lacunas. Ser 
programador é entender que os erros vão existir e cabe ao programador, ou ao iniciante em programação, que deve manter a cabeça 
no lugar e recomeçar, já que um erro é sinal de que algo precisa ser reajustado. O erro tão somente quer dizer “revise e corrija”. Erros 
de programação são fundamentais, e saber os reconhecer, ajuda o programador a encontrar a solução para sua correção. A definição 
de um erro, de acordo com o dicionário é: ato ou efeito de errar; assim, trazendo para o contexto de programação, precisamos 
compreender o que seria o ato de errar. Por exemplo, considere o algoritmo a seguir queapresenta um problema: 
x == 10 
A variável x, como foi declarada está incorreta, pois utiliza dois sinais de igualdade violando a sintaxe do Python. Esse tipo de erro 
um erro de sintaxe. Geralmente um erro é resultado de um ato indevido realizado pelo programador. E em tese, ninguém comete um 
erro propositalmente. Em x==10, ou não se assimilou corretamente a sintaxe ou simplesmente foi cometido um erro de digitação. Alguns 
erros são causados pela má interpretação de um problema, e que pode resultar em um algoritmo sem erro de sintaxe, mas que produz 
um resultado incorreto; ou por fatores externos que afetam nossos programas. Por exemplo, ao enviar uma mensagem de texto no 
WhatsApp desconectado da Internet. Neste caso, o programa não possui erros de sintaxe e foi escrito para produzir a resposta correta, 
mas a falta de Internet fez com que o programa não cumprisse seu objetivo. Este é um exemplo de erro em tempo de execução, e não é 
um erro na verdade, mas a falta de um recurso essencial para que o programa possa efetuar a tarefa que foi projetada, mas o programa 
entende como um erro, já que não atende aos requisitos de funcionamento. 
2.6.1 Erro de sintaxe 
Ocorre sempre que uma instrução de programação é escrita incorretamente e viola alguma das regras (sintaxe) do Python. É muito 
comum no início do aprendizado quando o profissional está começando a entender os processos e como funciona cada declaração do 
programa. 
2.6.2 Interpretando mensagens de erro 
No código: 
nome=”Josué 
Observamos que apenas uma aspas dupla foi usada ao declarar a variável nome, e como já visto, a declaração de uma variável tem 
que vir entre “ ” (aspas). Ao executar o código usando a Python Sandbox | Text Mode ( https://www.pythonsandbox.com/) , que 
podemos usar para testar os nossos conceitos de solução de problemas temos o seguinte resultado: 
 
Temos o erro ParseError: bad token on line 1 
Usando a IDLE Shell, obtivemos a janela com o erro: 
 
 
 
 
 
FIG. 20 – REPRESENTAÇÃO DO ERRO GERADO NO SANDBOX ONLINE 
FIG. 21 – REPRESENTAÇÃO DO ERRO NO EDITOR DO IDLE SHELL 
https://www.pythonsandbox.com/
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[59] 
 
Em todas elas são informados a linha que o erro aconteceu, também é apresentado um tipo de erro, ou uma SyntaxError ou um 
ParseErro. E segue falando que foi indeterminado a String literal. Os erros não aparecem muito claros no Sandbox, mas mesmo assim 
dá para usá-la para criar e debugar programas. É pouco provável que um iniciante em Python vá entender que undeterminated string 
literal (String literal indeterminada) seja a falta das aspas, o que é claro é que ele não conseguiu determinar o fim de uma String Literal, 
e como determinamos Strings através da abertura e fechamento de aspas, o Python encontrou a abertura, a String e ficou procurando 
o fechamento e não conseguiu determinar onde a String acabava. Situações com esta de Sintaxe, são comumente ignoradas, e pode 
frustrar as pessoas. 
 
2.6.3 Categorias de erros de sintaxe 
Há uma variedade de situações que podem causar erros de sintaxe, o Python subdivide em três categorias: 
• SyntaxError 
• NameError 
• TypeError 
A primeira categoria apresenta problemas com a escrita de instrução e que violam a sintaxe do Python, a segunda categoria refere-
se a problemas com o uso da variável, como tentar utilizar uma variável não declarada (muito comum) e a terceira ocorre quando 
usamos tipos de variáveis incorretas para fazer uma operação, como somar “2” + 2 , somar uma String com um Literal Inteiro. 
SyntaxError(indica o uso incorreto da sintaxe) 
PROBLEMA 01 INVERTER A ORDEM NA ATRIBULÃO DE DADOS VARIÁVEIS 
Algoritmo 
incorreto 
2 = X 
Mensagem de 
erro 
SyntaxError: cannot assign to literal (não se pode associar ao 
literal) 
Solução X = 2 
 
PROBLEMA 02 DECLARAR UMA STRING SEM ASÁS DE ABERTURA OU FECHAMENTO 
Descrição As Strings precisam ser declaradas com aspas de abertura e 
fechamento 
Algoritmo 
incorreto 
nome= “Josué 
Mensagem de 
erro 
SyntaxError: undeterminated string literal (não se pode 
associar ao literal) 
Solução name = “Josué” 
 
PROBLEMA 03 AUSÊNCIA DE NÚMEROS NUMA OPERAÇÃO MATEMÁTICA 
Descrição As operações matemáticas devem ser realizadas entre pares de 
números. 
Algoritmo 
incorreto 
x = 2 + 
Mensagem de 
erro 
SyntaxError: invalid syntax 
Solução x = 2 + 3 
 
FIG. 22 – REPRESENTAÇÃO DO ERRO NO WINDOWS POWER SHELL RODANDO PELA PVM 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[60] 
NameError(declaração incorreto de variáveis. Também ocasionados por violação de sintaxe) 
PROBLEMA 04 DECLARAR UMA VARIÁVEL COM DUAS IGUALDADES 
Descrição A sintaxe para declarar uma variável requer apenas um sinal de 
igualdade 
Algoritmo 
incorreto 
x == 2 
Mensagem de 
erro 
SyntaxError: name ‘x’ is not defined 
Solução x = 2 
 
PROBLEMA 05 UTILIZAR UMA VARIÁVEL NÃO DECLARADA 
Descrição O computador ler o algoritmo de cima para baixo, assim na 
execução da linha 1 ainda não á uma variável criada com o nome 
y, e o erro ocorrerá 
Algoritmo 
incorreto 
x = y 
Mensagem de 
erro 
SyntaxError: name ‘x’ is not defined 
Solução Y = 2 # Declarar a variável ante de a usar 
x = y 
 
TypeError(na realização de operações entre variáveis que são de tipos diferentes) 
PROBLEMA 06 REALIZAR OPERAÇÕES COM VARIÁVEIS DE TIPO DIFERENTES 
Descrição Não é possível conectar uma String com números ou somar números 
com Strings. 
Algoritmo 
incorreto 
nome = “Josué, idade ”+34 
Mensagem de 
erro 
SyntaxError: name ‘x’ is not defined 
Solução nome = “Josué, idade 34” 
 
2.7 Localizando um erro 
É um grande desafio para quem está programando é localizar a instrução que causou o erro, requer um entendimento sobre as 
consequências que o seu erro pode causar e qual a instrução provocou o erro em questão. E quanto maior o código maior a dificuldade 
para se encontrar o erro. O Python oferece indicações do erro, mas nem sempre ela é precisa, ela pode ocasionar de um erro anterior, 
por exemplo: Calcule o módulo do número X e Y e depois dívida 1000 por esse valor. Se o resultado for de uma conta exata, ou seja, o 
modulo dos dois números é zero, vai gerar um erro, já que não existe divisões por zero. Outros casos a linha está correta, mas a causa 
do erro se encontra em outra linha. E de fato tem que se lembrar, execução de cima para baixo e da esquerda para direita e de cima 
para baixo. Como mostrado 
x=2 
y=”2” 
soma=x+y 
Rodando em Python soma.py temos o erro: 
 
FIG. 23 – REPRESENTAÇÃO DO ERRO NO WINDOWS POWER SHELL RODANDO PELA PVM 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[61] 
Apesar de a indicação da linha do algoritmo que resultou neste problema está correta, o problema é anterior a linha, ode a variável 
y foi declarada como String e não numérica. Logo o aviso sobre o erro em seu código, observe a linha indicada, mas também revise as 
linhas anteriores que podem afetar a linha em questão. 
2.8 Erros lógicos 
Existem situações em que o algoritmo não apresenta erros de sintaxe, mas não produz o resultado esperado. Veja o código a seguir 
que seria utilizado para converter de metros para centímetros: 
metros = 1 
centimetros = metros/100 
Ao executar esse algoritmo não será indicado qualquer um dos erros anteriores, pois de fato não está errado em alfabeto, nem em 
sintaxe, tão pouco está errado em lexus, ou na semântica. Entretanto, o resultado da conversão será errado, em entendimento do que 
se pede o programa, já que se deve utilizar a multiplicação e não divisão. Em casos como esse dizemos que o código está logicamente 
incorreto, e os erros lógicos ocorrem por diferentes motivos. Pode acontecer do desenvolvedor não saber como uma determinada 
operação deve proceder. Em outros casos pode ocorrer uma má interpretação do problema que está sendo resolvido. Por exemplo, 
uma escola pode solicitar um sistema para calcular os aprovados de um ano letivo e o programador considerara nota mínima como 
sendo 6, quando na realidade é 7. Assim, torna-se fundamental entender corretamente o problema que será resolvido com a 
programação, o que nem sempre é um processo fácil. O uso incorreto de recursos da programação também pode ocasionar erros 
lógicos e não nos referimos ao uso indevido em sintaxe, como geralmente é apresentado, mas uma falha na compreensão sobre como 
um recurso da programação deveria ser utilizado. A seguir exemplificamos este problema, onde o desenvolvedor representou o número 
1.000 de uma forma incorreta. Na sequência ele realizou o cálculo de dez por cento deste valor. 
valor = 1.000 
percentual = 0.1 
resposta = valor * percentual 
Muitos aprendizes cometem esse erro, pois trazem essa representação numérica do dia a dia para a programação. No entanto, 
como discutido no capítulo anterior, sabemos que está incorreta em sintaxe, mas pelo fato de o Python não apontar a possível causa 
para os erros lógicos eles são mais difíceis de serem corrigidos. Utilizar fóruns de programação (como o Stack Overflow - 
https://pt.stackoverflow.com/) ou pedir ajuda a amigos é uma estratégia que pode ser utilizada caso não consiga localizar o problema. 
Em resumo, a solução para os erros passa por: reconhecer o erro, refletir sobre seu conhecimento e se necessário, pedir ajuda (em 
fóruns, colegas, professores ou revisando o conteúdo de um livro ou esse material). Também é importante compreender que eles fazem 
parte do aprendizado, sendo natural cometê-los. 
Erros muito comuns 
Entrada e saída de dados é um dos primeiros assuntos que aprendemos, já que são essenciais, pois é o propósito de um programa, 
receber um dado, processar e gerar uma saída. Se não for assim perde-se o propósito de se ter um algoritmo. Algumas confusões 
entre instruções podem ocorrer, principalmente quando estamos iniciando confundir a função input com a função print, por 
exemplo, acreditando que a primeira realiza a impressão, se fato realiza, mas uma é específica para leitura de dados e a outra para 
mostrar o dado na tela. Outra é esquecer de converter tipos antes de executar uma operação qualquer, pedir para um usuário entrar 
um numero e não o converter antes de realizar uma operação matemática, ou mesmo ter um numero e querer concatena-lo sem o 
converter para uma String. 
Código com problema Código Resolvido 
numero=input() 
soma=numero+2 
numero=input() 
soma=int(numero)+2 
 
 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[62] 
2.9 Questões 
1. O que são variáveis na programação? 
2. Por que as variáveis recebem esse nome? 
3. O que aconteceria se não fosse possível armazenar dados em um programa? 
4. Assinale com V (verdadeiro) ou F (falso) as afirmações a seguir: 
( ) O nome de uma variável pode começar com número. 
( ) Podemos utilizar espaços no nome de uma variável. Assim, a variável de nome "senha do usuário" é considerada válida. 
( ) Podemos utilizar acentos e caracteres especiais nos nomes das variáveis, porém devemos evitá-los. 
( ) Uma variável pode armazenar mais de um valor. 
5. Quais nomes de variáveis estão INADEQUADOS? 
( ) total_inimigos_derrotados 
( ) total_dinheiro$$ 
( ) %_de_acertos 
( ) quantidade de mensagens 
6. Imagine que você deseja armazenar o nome de uma pessoa em uma variável, qual seria um bom nome para ela? 
( ) n 
( ) senha 
( ) nome 
7. Por que as variáveis precisam de um nome? 
8. A declaração de uma variável é composta por três partes, quais são elas? 
9. Assinale V ou F para as afirmações a seguir: 
( ) A declaração de uma variável segue a sintaxe: nome = valor 
( ) A declaração de uma variável segue a sintaxe: nome == valor 
( ) A seguinte declaração de variável está correta: dado = 30% 
( ) A seguinte declaração de variável está correta: dado = R$ 30 
( ) A seguinte declaração de variável está correta: dado = 0.3 
10. Explique como o computador lê o nosso algoritmo. 
11. Declare duas variáveis, uma com número inteiro e outra com um número decimal. 
12. Como representar variáveis que guardam os números percentuais a seguir: 30%, 5%, 75% e 6.5%. 
13. Qual o problema nos código a seguir: 
dado = 30.5 
outro_dado = mais_um_dado 
14. O que variáveis do tipo String armazenam? 
15. Para declarar uma variável String devemos colocar o valor entre: 
( ) Parênteses ( ) Colchetes 
( ) Aspas ( ) Asterisco 
16. Declare uma variável para representar o valor do seguinte texto: Estou lendo um livro de introdução à programação. 
17. Qual o operador utilizado para concatenar textos? 
( ) igualdade ( ) subtração 
( ) mais ( ) aspas 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[63] 
18. Por que utilizamos o operador de concatenação? 
19. Realize a concatenação de duas variáveis do tipo texto. Você pode definir os valores que achar mais adequado. 
20. Quais são os valores que uma variável booleana pode possuir? 
21. Em quais situações nós usamos variáveis booleanas? 
22. Marque com V ou F as situações a seguir que podem ser representadas como booleanas: 
( ) O estado de uma lâmpada que pode estar acesa ou apagada; 
( ) A velocidade de um carro; 
( ) O saldo de dinheiro na conta de uma pessoa; 
( ) A situação de um estudante que pode estar aprovado ou reprovado. 
23. Escreva os operadores matemáticos utilizados no Python para realizar as seguintes operações matemáticas: 
( ) Soma 
( ) Subtração 
( ) Divisão 
( ) Multiplicação 
24. Qual a importância dos operadores matemáticos para a programação? 
25. Qual é o valor da variável pontuação após a execução do algoritmo? 
pontuacao = 10 
pontuacao = pontuacao + 3 
26. Qual será o valor de x após a execução do algoritmo? 
x = 2 
y = x 
y = y*2 
x = y/2 
27. O algoritmo a seguir possui um erro, pois não calcula corretamente uma média. O que é necessário para corrigi-lo? 
pontuacaoUm = 10 
pontuacaoDois = 15 
pontuacaoTres = 5 
media = pontuacaoUm + pontuacaoDois + pontuacaoTres/3 
28. O que são os operadores de atribuição compostos e quais os benefícios em utilizá-los? 
29. Considere um algoritmo com duas variáveis, sendo um número par e outro ímpar. Qual operador poderia ser utilizado para 
descobrir quem é o par e quem é o ímpar? 
30. Usando os argumentos sep e end, qual a função que produziria esse resultado na tela: Programação*** 
Essencial***em...Python 
31. Que tipos de literais são os dois exemplos seguintes? 
"Hello ", "007" 
32. Que tipos de literais são os quatro exemplos seguintes? 
"1.5"; 2.0, 528, False 
33. Qual é o valor decimal do seguinte número binário, como programar no Python? 
1011 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[64] 
34. Desenhe um quadrado usando a função print() use os símbolos + para os cantos, - para as arestas horizontais, | para as 
arestas verticais. Faça com 12 caracteres horizontais e 6 verticais. O código tem que ter no máximo 3 linhas. Ao terminar duplique 
o tamanho. 
35. O exemplo do programa gera uma seta: pede-se 
print(" *") 
print(" * *") 
print(" * *") 
print(" * *") 
print("*** ***") 
print(" * *") 
print(" * *") 
print(" *****") 
 
a) reescrever o programa em uma linha, reduzindo para apenas um comando print. 
b) fazer a seta duas vezes maior (mantendo as proporções) 
c) duplicar a seta, colocando uma do lado da outra 
d) retirar qualquer uma das aspas e ver o que ocorre 
e) alterar a palavra print por outra palavra qualquer como Print 
d) Substituir algumas das aspas por apóstrofo e ver o que ocorre 
36. Escreva um Código de uma linha com a função print(), caracteres newline e de escape, para corresponder ao resultado de três 
linhas. 
"I'm" 
""learning"" 
"""Python""" 
37. Numa operação matemática, obtenha o valor inteiro das divisões e o resto, coloque em uma única linha de programação para: 14 
dividido por 4 
38. Qual é o output do seguinte código? 
print((2**4),(2*4.),(2*4)) 
39. Qual é o output do seguinte código? 
print((-2/4),(2/4),(2//4),(-2//4)) 
40. Qual é o output do seguinte código?print((2%-4),(2%4),(2**3**2)) 
41. Construir um programa curto que resolva problemas matemáticos simples, como o teorema de Pitágoras: o quadrado da 
hipotenusa é igual a soma do quadrado dos catetos. Considerem o comprimento da hipotenusa (o lado mais longo do triangulo) 
usando o teorema de Pitágoras. 
Dados: c1 = 3.0; c2=4.0 calcule h=? 
42. Uma vez em Appleland, o John tinha três maçãs, a Mary tinha cinco maçãs, e o Adam tinha seis maçãs. Todos eles foram muito 
felizes e viveram durante muito tempo. Fim da história. 
• A sua tarefa é: criar as variáveis: john, mary, e adam; 
• atribuir valores às variáveis. Os valores devem ser iguais ao número de frutos possuídos pelo John, pela Mary e pelo Adam, 
respetivamente; 
• tendo armazenado os números nas variáveis, imprimir as variáveis numa linha, e separar cada uma delas com uma vírgula; 
• criar agora uma nova variável chamada total_apples igual à adição das três variáveis anteriores. 
• imprimir o valor armazenado em total_apples para a tela; 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[65] 
• Sugestão: experimente com o seu código: crie novas variáveis, atribua-lhes valores diferentes e efetue várias operações 
aritméticas sobre elas (por exemplo, +, -, -, *, /, //, etc.). Tente imprimir uma string e um inteiro juntos numa linha, por 
exemplo, "Número total de maçãs:" e total_apples. 
43. Milhas e quilómetros são unidades de comprimento ou distância. Tendo em mente que 1 milha é aproximadamente igual a 1.61 
quilómetros, complete o programa no editor para que ele converta: 
milhas para quilómetros; 
quilómetros para milhas. 
Não altere nada no código existente. Escreva o seu código nos locais indicados por ###. Teste o seu programa com os dados que 
fornecemos no source code. Preste especial atenção ao que está a acontecer dentro da função print() . Analise como fornecemos 
múltiplos argumentos à função, e como produzimos os dados esperados. Note-se que alguns dos argumentos dentro da função print() 
são strings (por exemplo, "miles is", enquanto alguns outros são variáveis (por exemplo, miles). 
SUGESTÃO:Há mais uma coisa interessante a acontecer ali. Consegue ver outra função dentro da função print() ? É a função round() 
. O seu trabalho é o de arredondar o resultado em output para o número de casas decimais especificadas nos parêntesis, e devolver 
um float (dentro da round() função pode encontrar o nome da variável, uma vírgula, e o número de casas decimais que pretendemos). 
Vamos falar sobre funções muito em breve, por isso não se preocupe caso ainda não esteja tudo totalmente claro. Só queremos 
despertar a sua curiosidade. 
Depois de concluir o lab, abra a Sandbox e experimente mais. Tente escrever conversores diferentes, por exemplo, um conversor 
de USD para EUR, um conversor de temperatura, etc. - deixe que a sua imaginação voe! Tente fazer output dos resultados combinando 
strings e variáveis. Tente usar e experimentar com a round() função para arredondar os seus resultados a uma, duas ou três casas 
decimais. Verifique o que acontece se não fornecer qualquer número de dígitos. Lembre-se de testar os seus programas. 
Experimente, tire conclusões, e aprenda. Seja curioso. 
Output esperado 
7.38 milhas equivalem a 11.88 Km 
12.25 km equivalem a 7.61 milhas 
Código: 
kilometers = 12.25 
miles = 7.38 
 
miles_to_kilometers = ### 
kilometers_to_miles = ### 
 
print(miles,"milhas equivalem a",round(miles_to_kilometers,2),"Km") 
print(kilometers,"Km equivalem a",round(kilometers_to_miles,2),"milhas") 
x = # hardcode your test data here 
x = float(x) 
 
# escreva seu código aqui 
 
print("y =", y) 
 
44. Veja o código no editor: ele lê um valor float , coloca-o numa variável chamada x, e imprime o valor de uma variável chamada y. A 
sua tarefa é completar o código para avaliar a seguinte polinômio: 3x3-2x2+3x-1 , o resultado deve ser atribuído a y. 
Lembre-se que a notação algébrica clássica gosta de omitir o operador de multiplicação - precisa de o utilizar explicitamente. Note 
como alteramos o tipo de dados para garantir que x é do tipo float. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[66] 
Mantenha o seu código limpo e legível, e teste-o usando os dados que fornecemos, atribuindo-o cada vez à variável x (por 
hardcoding). Não desanime por quaisquer falhas iniciais. Seja persistente e inquisitivo. Dados de teste 
Entrada Saída Esperada 
x= 0 y=-1.0 
x= 1 y= 3.0 
x=-1 y=-9.0 
 
45. Qual é o output do seguinte código? 
var = 2 
var = 3 
print(var) 
46. Quais dos seguintes nomes de variáveis são inválidos em Python? 
( )my_var ( )m ( )101 ( )averylongvariablename 
( )m101 ( )m 101 ( )Del ( )del 
47. Qual é o output do seguinte snippet? 
a = '1' 
b = "1" 
print(a + b) 
48. Qual é o output do seguinte snippet? 
a = 6 
b = 3 
a /= 2 * b 
print(a) 
49. O código no editor contém comentários. Tente melhorá-lo: adicione ou remova comentários onde achar apropriado (sim, por vezes 
remover um comentário pode tornar o código mais legível), e altere nomes de variáveis onde achar que isso irá melhorar a 
compreensão do código. 
#este programa calcula o número de segundos num dado número de horas 
#este programa foi escrito a uns dois dias atrás 
 
a = 2 # número de horas 
segundos = 3600 # número de segundos em 1 hora 
 
print("Hours: ", a) #imprimindo o número de horas 
#print("Segundos em Horas: ", a * segundos) # imprimindo o número de segundos 
 
#Aqui deveria imprimir "Adeus", mas o programador não teve tempo 
#aqui termina o programa que computa o número de segundos em 3 horas 
NOTA Os comentários são muito importantes. São utilizados não só para facilitar a compreensão dos seus programas, mas também 
para desativar as partes do código que atualmente não são necessárias (por exemplo, quando precisa de testar apenas algumas partes 
do seu código e ignorar outras). Bons programadores descrevem cada parte importante do código e dão nomes self-commenting às 
variáveis, já que por vezes é simplesmente muito melhor deixar informação no código. 
É bom usar nomes de variáveis legíveis, e por vezes é melhor dividir o seu código em partes nomeadas (por exemplo, funções). Em 
algumas situações, é uma boa ideia escrever os passos dos cálculos de uma forma mais clara.Mais uma coisa: pode acontecer que um 
comentário contenha uma informação errada ou incorreta - nunca se deve fazer isso de propósito! 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[67] 
50. Qual é o output do seguinte snippet? 
# print("String #1") 
print("String #2") 
51. O que acontecerá quando executar o seguinte código? 
# This is 
a multiline 
comment. # 
 
print("Hello!") 
52. Sua tarefa é completar o código a fim de avaliar os resultados de quatro operações aritméticas básicas. Os resultados têm de 
ser impressos para a consola. Poderá não conseguir proteger o código de um utilizador que queira dividir por zero. Tudo bem, não 
se preocupe com isso por agora. Teste o seu código - produz os resultados que espera? 
Não lhe mostraremos quaisquer dados de teste - isso seria demasiado simples. 
# input a float value for variable a here 
# input a float value for variable b here 
 
# output the result of addition here 
# output the result of subtraction here 
# output the result of multiplication here 
# output the result of division here 
 
print("\nThat's all, folks!") 
 
(intermediário) 
53. (Intermediário)Familiarizar-se com o conceito de números, operadores e operações aritméticas em Python; compreender a 
precedência e associatividade dos operadores Python, bem como o uso adequado de parêntesis. 
Cenário: A sua tarefa é a de completar o código, de forma a avaliar a seguinte expressão:𝑓𝑓(𝑥𝑥) = 1
𝑥𝑥+ 1
𝑥𝑥+ 1
𝑥𝑥+1
𝑥𝑥
 
O resultado deve ser atribuído a y. Tenha cuidado - observe os operadores e mantenha as suas prioridades em mente. Não hesite 
em utilizar os parêntesis de que necessitar.Pode utilizar variáveis adicionais para encurtar a expressão(mas não é necessário). Teste 
o seu código com cuidado. 
Dados de Teste 
Entrada Saída 
f(1) y= 0.6000000000000001 
f(10) y= 0.09901951266867294 
f(100) y= 0.009999000199950014 
f(-5) y=-0.19258202567760344 
programa: 
x = float(input("Enter value for x: ")) 
 
# Write your code here. 
 
print("y =", y) 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[68] 
54. (Intermediario)A sua tarefa é preparar um código simples capaz de avaliar o tempo final de um período de tempo, dado como um 
número de minutos (pode ser arbitrariamente grande). O tempo inicial é dado como um par de horas (0.. 23) e minutos (0.. 59). O 
resultado tem de ser impresso para a consola. 
Por exemplo, se um evento começar às 12:17 e durar 59 minutos, ele terminará às 13:16. 
Não se preocupe com quaisquer imperfeições no seu código - não faz mal se aceitar um tempo inválido - o mais importante é que 
o código produza resultados válidos para dados de input válidos. Teste o seu código com cuidado. Dica: utilizar o operador % 
pode ser a chave para o sucesso. 
Dados de teste 
HORA MINUTOS DURAÇÃO RESULTADO 
12 17 59 13:16 
23 58 642 10:40 
0 1 2939 1:0 
Programa: 
hour = int(input("Starting time (hours): ")) 
mins = int(input("Starting time (minutes): ")) 
dura = int(input("Event duration (minutes): ")) 
 
# Write your code here. 
55. Qual é o output do seguinte snippet? 
x = int(input("Enter a number: ")) # The user enters 2 
print(x * "5") 
56. Qual é o output do seguinte snippet? 
x = input("Enter a number: ") # The user enters 2 
print(type(x)) 
 
57. Calculando Rendimentos 
Escrever um programa que comece definindo as seguintes variáveis: inicial e juros. A variável inicial vai 
representar a quantia inicial investida na poupança. A variável juros vai representar o juros mensal da poupança, ou seja, quanto 
porcento você ganha em cima do valor que você possui. Por exemplo, se você quiser considerar uma quantia inicial de R$ 4.000,00 
e um juros de 0,5% ao mês, você poderia escrever: 
inicial = 4000 
juros = 0.5 
Usando essas variáveis, calcule quanto a pessoa teria ao final de um ano. 
Dados: Juros Simples = 𝐶𝐶𝐶𝐶𝐶𝐶
100
 onde: C=Capital, i=taxa%, t=período investidos M=montante => M=C+Juros Simpes 
Juros Compostos = 𝐶𝐶(1 + 𝑑𝑑)𝐶𝐶 
Dica 1: se o juros da poupança é de X%, a cada mês você precisa multiplicar o valor por 1+(X/100) para obter o valor ao 
fim do mês (ou seja, o valor após aplicar os juros). Então para saber o valor ao final do ano, você precisa fazer isso 12 vezes. 
Dica 2: assim como o operador += permite abreviarmos x = x+y para x+=y, nós podemos abreviar x = x * y por 
x *= y. 
58. Leia os códigos a seguir e indique qual tipo de erro de sintaxe (SyntaxError, NameError e TypeError) eles apresentam: 
a. x = 2 
 y = "4" 
 soma = x + y 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[69] 
b. idade = "40 
c. livro = Programacao 
59. O código a seguir foi construído para calcular uma média. Há algum problema? Se sim, qual seria a sua 
correção? 
nota_um = 10 
nota_dois = 5 
nota_tres = 4 
media = nota_um + nota_dois + nota_tres / 3 
60. Analise a mensagem de erro a seguir e identifique as suas partes: trecho do código com problema, sua linha, 
o tipo de erro e a mensagem específica do erro. 
 
61. Assinale Verdadeiro (V) ou Falso (F) para as afirmações: 
( ) A entrada de dados possibilita ao nosso algoritmo receber informações digitadas pelo usuário. 
( ) Nossos algoritmos são limitados a uma entrada de dados. 
( ) Para realizar a leitura de dados nós utilizamos a instrução `print`. 
62. Crie um algoritmo para realizar a leitura de um dado e o armazene em uma variável. 
63. Crie um algoritmo para realizar a leitura de um dado, informando ao usuário sobre o que ele precisa digitar. 
64. Crie um algoritmo para realizar a leitura de dois textos do teclado e faça a sua concatenação. 
65. Assinale Verdadeiro ou Falso para as afirmações: 
( ) A saída de dados é uma forma de apresentar informações ao usuário. 
( ) A instrução `print` é usada para apresentar informações ao usuário. 
( ) É possível realizar operações matemáticas em variáveis do tipo String. 
( ) Para realizar a unificação de dados com Strings é preciso converter o dado em questão para String utilizando `str`. 
66. Crie um algoritmo para realizar a leitura de um dado e o converta para inteiro. 
67. O algoritmo de calculadora abaixo está incompleto, pois não apresenta o resultado da operação na tela do usuário. Escreva a 
instrução necessária para realizar esse procedimento: 
numero_um = input() 
numero_dois = input() 
resultado_soma = int(numero_um) + int(numero_dois) 
resultado_soma_texto = str( resultado_soma ) 
mensagem = "O resultado da soma é: "+resultado_soma_texto 
68. Usando um dos operadores de comparação em Python, escreva um programa simples de duas linhas que toma o parâmetro n 
como input, que é um inteiro, e imprime False Se n for menor que 100, e True Se n for maior ou igual que 100. Não use nenhum 
comando que não foi visto até agora. 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[70] 
3. Estrutura Condicional 
Para entendermos como é importante as condições na estrutura de programação, é necessário entender como elas também está 
presentes em nossas vidas. Diariamente tomamos decisões com bases comparativas. Ao nos vestirmos comparamos se cores 
combinam ou não, se bem que a moda está tão livre que tudo combina com tudo, é o high fashion designe. Vamos usar melhor 
comparações, comprar um pão leva muitas variáveis, se eu acordei tarde, não terei tempo de ir a uma padaria comprar um pão, se não 
tiver dinheiro ou se não tiver crédito para comprar o pão, vai ser impossível. O tempo todo estamos usando condições, se isso, se aquilo 
ou se não aquilo outro. Como clientes de um banco, e sem dinheiro na carteira precisamos sacar dinheiro para comprar o pão, ao 
chegar no caixa se o saldo for positivo, se essa condição não for satisfeita, todas as ações vinculadas ao saque, como o de liberar 
dinheiro, diminuir o saldo e até a compra do bendito pãozinho não serão realizadas. 
Os softwares como um geral apresentam inúmeras condições, ou caminhos a serem percorridos, e como gostamos de explorar o 
significado das palavras, uma condição é uma Ideia de que uma coisa depende de outra para poder acontecer. No nosso exemplo do 
pãozinho, eu só posso comprar dependendo das condições se eu tenho tempo, e depois se eu tenho dinheiro. Se uma dessas duas 
condições não ocorrerem eu não terei meu pãozinho quente para o café da manhã. E com essa interdependência, um programador pode 
criar diversas instruções de programação que podem ser processadas a partir de uma verificação ou de diversas. 
3.1 Sintaxe para a criação das condições 
Precisamos inicialmente saber quando elas serão necessárias em nosso programa. Que será necessário que o problema proposto 
determine a necessidade do uso. Condições de um programa qualquer são diferentes de um software para outro, e até mesmo dentro 
de um mesmo software. Ao reconhecer que um programa depende de algum tipo de decisão, pode ser que exista a chance de adicionar 
uma condição. Precisamos pensar a real necessidade, reconhecer algo como, aqui só resolvo com uma condição, O conceito de estado 
de um programa é importante, o programa uma vez usado pode ofertar um tipo de condição que pode mudar, ou durante o uso, ou 
durante os vários usos. Por exemplo, um programa de tiro, você inicia o jogo, e tem um número x de balas, e com o uso você pode atingir 
um número crítico de balas, que vai forçar você tomar certa decisão, ou comprar balas, ou procurar por balas no jogo, e se você não 
alcançar esse objetivo o jogo vai impor duras condições de jogo, ou mesmo você vai perder porque não tem bala e não vai poder se 
defender. O mesmo num banco, que vou tirar dinheiro e não tenho saldo, e chega o começo do mês, recebemos o salário e ao voltar no 
caixa, a condição do programa será outra, e o caixapermite a retirada. Logo podemos dizer que as condições constroem as decisões 
que os computadores irão realizar. Isso é ver a partir de um critério criado ao programar, e que usam os valores armazenados nas 
variáveis. E como seria uma sintaxe condicional: 
SE o valor do saque é MENOR OU IGUAL ao valor do saldo bancário da conta, ENTÂO realizar a operação de saque. 
A palavra SE, expressa a ideia de condição, que compara um valor com outro, e permite ou não que algo seja feito se verdadeiro ou 
se falso. A maior característica de uma condição, é a de permitir o programador especificar um critério que será usado para determinar 
um conjunto de instruções a ser executado na sequência. 
3.2 Representando uma condição – operador if 
No Python usamos a instrução if comparação: e as instruções que serão executadas quando a condição for verdadeira. A 
comparação deve ser feita entre um par de variáveis que avalia se >, =, . É crucial que o resultado dessa comparação usada 
pelo computador para definir se o conjunto de instrução será ou não executado. Após a comparação há um sinal de dois pontos (:), e 
nas linhas seguintes, escreve-se a instrução a ser executada, se a condição for verdadeira. 
If valor_saque = e nuca => ou = b: 
 print(“Maior”) 
Resultar em TypeError: ‘>’ not supporte between instances of ‘int’ and ‘str’, pois a variável b não é numérica e sim String. 
Atribuição = e igualdade == 
A comparação no Python usa == (igual igual) já a atribuição usa-se o = (igual) usar errado esses operadores irá gerar também um 
erro lógico. 
nome=input() 
if nome == “Ada Lovelace”: 
print (“A primeira programadora da história!”) 
A comparação realizada neste código é bastante comum é utilizada para saber se o valor de uma String é igual a um texto em 
específico. No código, se o usuário digitar Ada Lovelace, aparecerá uma mensagem A primeira programadora da história!. Devemos 
lembrar que o Python é Case Sensitive, e qualquer alteração na entrada do usuário com o comparativo feito na instrução if, o print não 
será mostrado em tela. 
cinema_aberto = True 
if cinema_aberto == True: 
 print(“Cinema está aberto”) 
Há uma sintaxe mais simplista para realizar essa comparação e que funciona somente com variáveis do tipo booleana: 
cinema_aberto = True 
if cinema_aberto: 
 print(“Cinema está aberto”) 
O if não precisa de um par de dados nas comparações booleanas. O Python por default considera True. Outra característica é usar 
o equivalente ao estado sendo 1 para True e O para False. 
dado = 1 
if dado==True: 
#escopo quando o dado for verdadeiro 
Outro_dado = 1 
if outro_dado==False: 
#escopo quando o outro_dado for falso 
 
# funciona também 
dado = 1 
if dado: 
#escopo quando o dado for verdadeiro 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[73] 
3.4 Operador else 
Aprendemos que o resultado de qualquer operação será um booleano (Verdadeiro ou Falso), vimos que o if emite uma resposta 
sempre que verdadeiro, no entanto existem outras condições que podem ser executadas quando uma comparação for Falsa. Sentimos 
falta no programa do Caixa Automático de um SE NÃO. Por exemplo, SE o valor do saque do cliente for menor ou igual que o valor do 
saldo, dê o dinheiro e subtraia o valor do saque ao valor do saldo, (E SE NÃO FOR? COMO PROCEDER?) ai é que entra um SE NÃO, se o 
valor do Saldo for melhor do que o valor pedido, informe que não há saldo suficiente. Em qualquer um dos casos agradeça por ter usado 
os serviços e encerre o programa. Como seria isso? 
Sitaxe: 
if comparação: 
# escopo do if 
else: 
 #escopo do else 
Aqui teve-se que colocar um if, já que o else só existe acompanhando do if. Mas o if pode existir sem um else. A leitura seria: Se 
em uma condição o resultado for verdadeiro, então execute as funções do if, senão execute as outras instruções. É bom intender que o 
else é o opostodo if, por isso ele não existe comparação, perceba na estrutura. No caso, se x > 1 execute, o else toma todos os outros 
casos para executar as suas instruções. 
Saldo= int(input(“Digite o saldo bancário”) 
Saque= int(input(“Digite o valor do saque”) 
 
if saldo >=saque: 
 Saldo -= saque 
 Print(“você realizaou um saque com sucesso.”) 
else: 
 print(“Você não possui saldo para realizar essa operação.”) 
Um Fluxograma para esclarecer a função 
 
 
 
 
 
 
 
 
 
 
 
 
 
INÍCIO 
REALIZAR SAQUE 
APRESENTAR 
MENSAGEM DE 
ERRO 
REDUZIR VALOR 
SACADO DO 
SALDO 
APRESENTAR 
MENSAGEM DE 
SUCESSO 
SALDO >= SAQUE 
SIM 
NÃO 
FIM 
FIG. 21 – EEMPLO DE UM FLUXOGRAMA DO PROGRAMA COM IF E ELSE 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[74] 
O demonstra a sequencia de ações implementadas no código anterior. Inicia-se pela intenção de saque, e segue para uma análise, 
que segue para a análise que vai definir a validade da ação, o losango faz o papel do if, quando o resultado for verdadeiro executa um 
conjunto de instruções, quando falso, outras instruções serão executadas. 
Exemplo: 
No caso do banco: Primeiro vamos considerar que o cliente tem R$ 100,00 no saldo, devemos fazer um programa que leia (leitura 
fictícia só iremos usar o que aprendemos até aqui, então para usar a variável saldo e atribuir um valor de R$ 100,00). É um caixa 
automático que é muito especial e inteligente que só executa duas operações 1-Depósito e 2-Saque e 0-Cancelar. O Caixa pede para o 
cliente inserir o cartão, (vamos simular com um cartão com um input vazio). Após o cliente inserir o cartão vai perguntar ao cliente o 
que ele deseja fazer e mostra na tela três opções: uma para depositar dinheiro, e a segunda para sacar dinheiro e a terceira para 
encerrar a operação - o caixa não pode aceitar nenhuma outra opção além de 1; 2 e 0. O sistema pede para o usuário entrar uma 
operação, e aguarda a confirmação. Se a opção for 0, o caixa agradece pelo uso dos serviços e finaliza. se for 1 o sistema entra no modo 
depositar dinheiro, o caixa eletrônico mostra o valor atual do saldo, e pergunta qual o valor a ser depositado, e o cliente entra o valor 
e confirma, o sistema acata o valor, informa a mensagem de inserir envelope com o dinheiro na portinha a ser depositado, o sistema 
pede a confirmação se o cliente já depositou o envelope com valor informado. Se o cliente confirmar com sim, o caixa fecha a portinha 
de depósito, adiciona o valor depositado ao valor do saldo do banco, mostra o novo saldo em tela, informa que o valor está sob análise 
até conferência, agradece pelo uso dos serviços do banco, e encerra o programa. Se a opção for para saque, o sistema mostra os 
valores disponíveis de cédulas no caixa, que será: R$ 10,00; R$ 20,00, R$ 50,00 e R$100,00, indicando que o valor a retirar tem que ser 
um múltiplo de um desses valores. O caixa deve pedir ao cliente para entrar um valor para saque, que não pode ser R$ 0,00, nem pode 
ser um múltiplo que não possa ser escrito como (n1*10+n2*20+n3*50+n4*100) onde um ou mais valores de nx podem ser zero, mas 
não todos, pelo menos um dos valores de nx tem que ser maior que zero. O valor entrado primeiramente é comparado com o valor do 
saldo, e se o saldo for maior ou igual ao valor solicitado, o caixa tem que escolher qual(is) cassete(s) (cassete ou gaveta é onde se 
guarda o dinheiro dentro de um caixa automático), vai escolher para a liberação do valor que vai liberar em cada um. E então deve ativar 
o mecanismo para liberar as notas referente ao valor solicitado, o sistema vai subtrair o valor do saldo, vai mostrar o novo valor do 
saldo e pedir a confirmação do cliente, vai agradecer por usar o serviço e encerrar. Caso o valor do saldo seja menor que o valor 
solicitado, o caixa vai informar o valor do saldo para o cliente e vai informar que o cliente está com saldo insuficiente, e vai agradecer 
pela utilização dos serviços. 
O exemplo acima pode parecer assustador, mas usando as técnicas aprendidas podemos desenhar um programa para: 
1. Entender o problema proposto; 
2. Caracterizar o problema; 
3. Representar o problema; 
4. Resolver o problema; 
1 – Entender o problema: Devemos primeiro ler o problema com muita atenção e entender o que ele vai fazer, vê se temos todas as 
ferramentas para criar o mesmo. Se não entender, devemos ler e reler até ficar bem entendido o que vai se fazer. No caso, iremos 
criar um caixa automático que executa três funções, Depósito, Saque e Finalizar. 
2 – Subdividir o problema, reduzir o problema em problemas menores de forma a ficar mais fácil o entendimento, e na ordem que 
acontecer. 
2.0 – Atribuir o valor do Saldo do cliente; 
2.1 – Pedir para o Cliente Inserir o cartão e aguardar a confirmação; 
2.2 – Mostrar em tela as três opções disponíveis 1 – Depósito; 2- Saque e 0-Cancelar; E aguarda que a resposta do cliente: 
2.3 – Verifica se o valor inserido pelo cliente é diferente de 0; 1 ou 2; se diferente, informa opção invalida e pede mais uma vez para 
escolher uma opção correta; caso o cliente insista em um numero diferente de 0;1;2, o programa vai atribuir o valor 0 como o 
valor da entrada pelo cliente 
2.4 – Início da rotina 0 – O sistema agradece pelo uso do sistema e finaliza o programa; 
2.5 – Início da rotina 1 – O sistema exibe na tela a operação, e mostra o saldo em conta; 
2.6 – O sistema pede para o cliente informar o valor que vai ser depositado, e aguar a confirmação; 
2.7 – O sistema pede para o usuário Inserir o envelope na portinha e solicita confirmação S- Sim ou N-Não 
2.8 – Inicio da sub-rotina N – Não, O sistema agradece pelo uso e cancela a operação e finaliza o programa; 
2.9 – Início da sub-rotina S – O sistema agradece o depósito, Adiciona o valor no envelope ao saldo do cliente, Informa o novo 
saldo e informa a mensagem que o saldo está sob análise, até conferência. Agradece pelo uso dos serviços e encerra o 
programa. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[75] 
2.10 – Início da rotina 2 - O sistema mostra em tela a opção solicitada de Saque, Mostra os valores das cédulas disponíveis nos 
cassetes, 
2.11 - O sistema pergunta ao cliente o valor que vai retirar e aguarda a confirmação; 
2.12 – O sistema compara se o valor de saque = R$ 0,00 se verdadeiro; o programa informa que o valor de saque é invalido e pede 
para o cliente inserir outro valor superior a zero; 
2.13 – O sistema compara novamente se o valor é superior a R$0.00, se falso, o sistema atribui o valor da opção zero, e roda a a 
rotina 0. 
2.14 – Se o valor for maior que R$ 0.00 o sistema compara se o valor é um múltiplo dos valores em cassete; 
2.15 – Se o valor não for um múltiplo dos valores em cassete, o programa informa que o valor do saque é indisponível no caixa 
automático, e pede para que o cliente insira um valor múltiplo de R$ 10,00; R$ 20,00; R$ 50,00 e R$ 100.00, aguardando 
resposta. 
2.16 – Se o valor continuar não sendo um múltiplo entre os valores em cassete, o programa assume opção =0 e inicia a rotina 0. 
2.17 – Se o valor de saque for um valor válido, múltiplo dos valores em cassete, o sistema compara o valor de saque com o valor do 
saldo, 
2.18 – se o saldo for inferior ao valor do saldo, o sistema informa o valor do saldo, informa que o saldo em conta é insuficiente; 
atribui o valor de opção é 0 e executa a rotina 0; 
 
2.19 - Se o valor do saldo é igual ou superior ao valor do de saque o sistema: 
2.20 – Calcula quais cassetes serão usados, e quanto vai retirar de cada um; 
2.21 – Libera o valor de cada cassete;(apenas mostra o valor de cada cassete multiplicado pelo quantitativo) 
2.22 – Subtrai o valor de retirada do valor do saldo 
2.23 – Mostra o novo saldo em tela, agradece pelo uso e encerra. 
 
 
3- Representar o problema (próxima página ver primeiro o Algorítmo) 
 
 
4- Resolver o problema 
 
# PROGRAMA CAIXA ELETRÔNICO 
 
input("Favor inserir o cartão magnético") #Simula a entrada de carão e aguarda um 
saldo=100.00#Simula a leitura do banco de dados e traz o saldo do cliente 
 
opcao=int(input(""" 
 MENU DE OPÇÕES 
 
 1 - Depósito 
 2 - Saque 
 0 - Cancelar 
 
 Entrar opção aqui: """)) 
#vendo se ta fora da faixa 
confere_menor=opcao=3 #TRUE ou FALSE (1 ou 0) 
conferencia=confere_maior+confere_menor #Booleanda OU se o resultado 1 fora de faixa 
 
if conferencia==True: 
 opacao=int(input(""" 
 Opção Inválida selecione 1, 2 ou 0: 
 
 1 - Para Depósito; 
 2 - Para Saque: 
 0 - Para Cancelar a operação e saír; 
 
 entrar opção aqui: """)) 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[76] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
início 
Exibe para inserir 
cartão 
Aguarda a inserção do 
cartão. 
opções: 1-Depósito; 2-
Saque; 0-cancelar 
Leitura do 
Saldo 
Aguarda a opção do 
cliente 
!= 0,1,2 ? Opção Inválisa, 
tente novamente 
Atribui 0(zero) a 
seleção do cliente 
!= 0,1,2 ? 
SIM 
SIM 
NÃO 
Aguarda a opção do 
cliente 
== 0? 
Agradece pelo uso do 
serviço 
Fim 
SIM 
== 1? 
DEPÓSITO 
Saldo: R$ 100,00 
SIM 
Valor a ser depositado? 
Coloque o envelope na 
abertura com o nome 
depósito; 
Confirme se inseriu o 
envelope 
NÃO 
Atribui 0(zero) a 
seleção do cliente 
Obrigado pela 
confiança.! 
Soma deposito ao 
valor do saldo 
Mostra o novo saldo 
com o aviso de 
conferencia 
SIM 
NÃO 
SAQUE 
R$ 10, R$20, R$50 E R$100 
NÃO 
Valor de saque? 
SIM 
== 0.00? Valor não pode 
ser R$ 0.00 
Entrar um múltiplo de R$ 10, R$ 
20 R$ 50 ou R$100 
Atribui 0(zero) a 
seleção do cliente ==0.00? 
SIM 
NÃO 
Multiplo? 
O valor inserido é um não 
múltiplo de R$10, R$20, 
R$50,R$100 
NÃO 
Insira um valor válido 
para saque 
NÃO 
Multiplo? 
Atribui 0(zero) a 
seleção do cliente 
Calcula quantas cédulas 
vão ser entregues de cada 
cassete. 
Saldo>=Saque 
SIM 
Saldo Insuficiente 
para efetuar o saque. 
NÃO 
Libera o valor por cassete( 
apenas mostra cada valor 
por cassete em tela 
Subtrai o valor do saque 
ao valor do saldo 
Mostra o valor do 
novo saldo em conta, 
e agradece 
FLUXOGRAMA CAIXA AUTOMÁTICO 
FIG. 22 – FLUXOGRAMA SIMPLIFICADO DE UM CAIXA AUTOMÁTICO COM APENAS 3 OPERAÇÕES 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[77] 
4 – Continuação da solução 
 
#Segunda conferencia se ta fora da faixa 
confere_menor=opcao=3 #TRUE ou FALSE (1 ou 0) 
conferencia=confere_menor+confere_maior #Booleanda OU se o resultado 1 fora de faixa 
 
if conferencia==True: 
 opacao=0 
 
if opcao==1: 
 print(f""" 
 =====================DEPÓSITO EM ENVELOPE ======================== 
 = SALDO ATUAL: R$ {saldo} = 
 ================================================================== 
 """) 
 deposito=float(input("Insira o valor depositado: R$ ")) 
 conferencia=deposito2 
 conferencia=cenferencia_menor+conferencia_maior 
 if conferencia==True: 
 opcao=0 
 print("opração cancelada!") 
 else: 
 if envelope==1: 
 saldo=saldo+deposito 
 print(f""" 
 Obrigado pela confiança!!! 
 Novo Saldo: R$ {saldo} 
 """) 
 opcao=0 
 else: 
 print("Operação cancelada!!!") 
 opcao=0 
if opcao==2: 
 saque=float(input(""" 
 #################################################### 
 ################# SAQUE ###################### 
 #################################################### 
 # O caixa dispões de cédulas de: # 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[78] 
 # R$ 10,00 R$ 20,00 R$ 50,00 e R$ 100,00 # 
 # # 
 # SELECIOR VALORES QUE SEJAM MÚLTIPLO DOS VALORES # 
 # QUE ESTÃO EM NOSSOS CASSETES. # 
 #################################################### 
 Insira aqui o valor de saque: R$ """)) 
 
 # CONFERENCIA SE É UM MULTIPLO DOS VALRES EM CASSETE 
 confere=saque%10 
 if confere>=1: 
 saque=float(input(""" 
 O VALOR REQUISITADO NÃO É UM MULTIPLO DE: 
 R$ 10,00 ou R$ 20,00 ou R$ 50,00 ou de R$ 100,00 
 
 POR FAVOR ENTRE NOVAMENE UM VALOR VÁLIDO: R$ """)) 
 
 # CONFERENCIA SE É UM MULTIPLO DOS VALRES EM CASSETE 
 confere=saque%10 
 if confere>=1: 
 print("Operação canceladade!!!") 
 opcao=0 
 
 n4=int(saque//100) 
 n3=int((saque-n4*100)//50) 
 n2=int((saque-n4*100-n3*50)//20) 
 n1=int((saque-n4*100-n3*50-n2*20)//10) 
 saldo=saldo-(n4*100+n3*50+n2*20+n1*10) 
 print(f""" 
 Foram liberadas as quantidades de notas: 
 {n4} de R$100,00, {n3} de R$ 50,00, {n2} de R$ 20,00 e {n1} de R$ 
10,00 
 Saldo: R$ {saldo} 
 """) 
 
if opcao==0: 
 print(""" 
 Obrigao por usar os nossos serviços! 
 Estamos sempre a disposição para o atender!!! 
 """) 
3.4.1 Multiplas comparações em uma condição 
As condições se apresentam nos exemplos comparações múltiplas que pode estender e muito o nosso programa, ter uma forma de 
comprar, por exemplos, valores acima 2 e valores abaixo de 0 pode reduzir e muito um programa. Ao invés de apresentarmos dois 
comandos if, poderíamos ter um só: 
SE a opção for maior que 2 E a opção for menor do que 0 ENTÂO informar que a opção é invalida. 
Observe que entre as duas comparações tem a letra E, que tem o papel de conjunção, pois indica que as duas comparações precisam 
ser verdadeiras para que as instruções possam ser executadas. Na programação temos um operador que utiliza um papel semelhante 
pertencente ao grupo de operadores lógicos. Esses operadores asseguram a formação de um escopo condicional permitindo a execução 
das condições simultâneas. 
OPERADOR DESCRIÇÃO DO USO 
and Utilizado quando se deseja que o escopo somente seja executado quando todas as comparações forem verdadeiras. 
or Utilizando quando apenas uma das condições das comparações for verdadeira. 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[79] 
3.4.2 Um pouco de eletrônica digital 
 
 
 
 
 
 
 
 
 
 
 
Observe que é assim que o computador fisicamente entende as entradas lógicas, a porta AND é como uma multiplicação dos termos 
da entrada, o resultado é a Multiplicação de 0 e 1., que pode ser vido na tabela verdade A x B. Já a porta OR é como se fosse uma soma, 
basta uma das condições serem satisfeitas para a saída acompanhar a entrada. E a porta inversora é o resultado barrado, ou seja, se 
entra 1 sai zero e se entra zero sai 1. Isso é importante para que se abra o pensamento para os comandos no Python, que aje com 
verossímil similaridade. 
3.4.3 O operador and (E) 
 
Como já falado, and é uma operação que significa um e outro, ou seja as duas condições tem que serem satisfeitas para que ela 
seja acionada. 
saldo = int( input("Digite o saldo bancário") ) 
saque = int( input("Digite o valor de saque") ) 
valor_sacado = 900 + saque 
 
if saldo >= saqueand valor_sacado 0 and saldo >= saque and valor_sacado 0 and saldo>=saque and valor_sacadp 1000: 
 print("Você excedeu o seu limite diário de saques.") 
else: 
 print("Você não possui saldo suficiente para realizar essa operação.") 
Aqui além de se guardar o saldo o cliente, diariamente tem uma variável que soma todo o valor armazenado numa variável 
valor_sacado, com esse controle o banco pode saber se o cliente atingiu o limite de saques diário, no nosso caso, R$ 1.000,00 por dia. 
3.4.7 Operadores de expressão condicional 
Um recurso do Python é de se escrever condições if e else por meiode um operador. Essa é uma expressão condicional. Também 
conhecida em outras línguas como operador ternário. 
Código original: 
numero = int( input("Digite um número") ) 
if numero > 4: 
 print("Número é maior que 4") 
else: 
 print("Número não é maior que 4") 
Refatoração: 
numero = int(input(“digite um número”)) 
print(“Número é maior que 4”) if numero>4 else print(“Numero não é maior que 4”) 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[82] 
A sintaxe dos operadores de expressão condicional: 
[resposta se verdadeira] if [comparação] else [resposta se falso] 
Esse tipo de expressão compacta os códigos, só que a aplicação se limita a situações de apenas uma instrução. 
3.4.8 Erros mais comuns 
Os códigos a seguir exemplificam os principais erros com condições: 
Ausência de dois pontos. O sinal de : não é utilizado para iniciar o escopo de uma condição (if, else ou elif). 
Código com problema: 
nome = input("Digite um nome") 
if nome == "Leonardo" 
Código corrigido: 
nome = input("Digite um nome") 
if nome == "Leonardo": 
Falta de indentação. Os códigos que fazem parte do escopo de uma condição precisam estar indentados (espaçados): 
Código com problema: 
nome = input("Digite um nome") 
if nome == "Leonardo": 
print("Olá Leonardo, como vai?") 
Código corrigido: 
nome = input("Digite um nome") 
if nome == "Leonardo": 
 print("Olá Leonardo, como vai?") 
Apenas uma igualdade na comparação. A comparação entre dados deve ser feita com dois sinais de igualdade. Muitos aprendizes 
utilizam apenas um. 
Código com problema: 
nome = input("Digite um nome") 
if nome = "Leonardo": 
Código corrigido: 
 
nome = input("Digite um nome") 
if nome == "Leonardo": 
Apenas um dado na comparação. Cada comparação realizada deve utilizar um par de dados, com exceção de variáveis booleanas.65 
Lembre-se que a notação algébrica clássica gosta de omitir o operador de multiplicação - precisa de o utilizar explicitamente. 
Note como alteramos o tipo de dados para garantir que x é do tipo float. ............................................................................................. 65 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[4] 
Mantenha o seu código limpo e legível, e teste-o usando os dados que fornecemos, atribuindo-o cada vez à variável x (por 
hardcoding). Não desanime por quaisquer falhas iniciais. Seja persistente e inquisitivo.............................................................................. 66 
Dados de teste ................................................................................................................................................................................................................. 66 
Input de amostra ..................................................................................................................................................... Erro! Indicador não definido. 
x = 0 ...................................................................................................................................................................... Erro! Indicador não definido. 
x = 1 ...................................................................................................................................................................... Erro! Indicador não definido. 
x = -1 .................................................................................................................................................................. Erro! Indicador não definido. 
Output esperado ...................................................................................................................................................... Erro! Indicador não definido. 
y = -1.0............................................................................................................................................................ Erro! Indicador não definido. 
y = 3.0 ............................................................................................................................................................... Erro! Indicador não definido. 
y = -9.0............................................................................................................................................................ Erro! Indicador não definido. 
resp .............................................................................................................................................................................. Erro! Indicador não definido. 
 
 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[5] 
I. EMENTA 
Conceitos básicos: interpretadores, sistema operacional, organização de computadores. Representação interna dos tipos básicos. 
Ambientes de programação: edição e execução de programas. Declaração de tipos em programação procedural, declaração de 
constantes, comandos de entrada/saída, comandos de atribuição, operadores aritméticos, operadores lógicos, operadores relacionais, 
comandos condicionais, comandos de repetição, técnicas de rastreamento de programas. Matrizes e variáveis estruturadas. 
II. OBJETIVOS GERAIS 
Desenvolver o raciocínio lógico aplicado à solução de problemas em nível computacional. 
III. OBJETIVOS ESPECÍFICOS 
A disciplina deve capacitar o aluno no uso de uma linguagem de programação como ferramenta de programação na implementação 
de soluções que envolvam os elementos básicos da construção de algoritmos e programas de computador, conforme abordado na 
disciplina Lógica de Programação e Algoritmos. Identificar qual a instrução computacional mais adequada para atender a determinado 
requisito lógico. 
IV. COMPETÊNCIAS 
Compreender as instruções da linguagem de programação Python. Ser capaz de utilizá-las de forma a implementar um determinado 
algoritmo. 
V. CONTEÚDO PROGRAMÁTICO 
MÓDULO 1: APRESENTANDO O PYTHON 
• Conceitos Básicos 
• O que é Python? 
• Vantagens do Python em relação a outras linguagens 
• Ambiente de desenvolvimento Visual Studio Code 
• Instalação do Python e IDE 
• Exemplos de Programas em Python 
MÓDULO 2: OPERADORES, EXPRESSÕES E VARIÁVEIS 
• Conceito de variável 
• Constantes e números 
• Expressões 
o Operadores matemáticos 
o Operadores de atribuição 
o Precedência dos Operadores 
MÓDULO 3: ESTRUTURA CONDICINAL 
• IF, ELIF e ELSE 
• SWITCH CASE 
MÓDULO 4: ESTRUTURA DE REPETIÇÃO 
• WHILE 
• FOR 
• BREAK/CONTINUE 
 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[6] 
MÓDULO 5: FUNÇÕES 
• Parâmetros 
• Variáveis locais e globais 
• Argumento default 
MÓDULO 6: STRINGS E ARQUIVOS 
• Manipulação de strings 
• Abertura, leitura e gravação em arquivos 
MÓDULO 7: MATRIZES 
• Manipulação básica de matrizes 
MÓDULO 8: ESTRUTURA DE DADOS 
• Lista 
• Tupla 
• Sequência 
• Conjunto(Set) 
MÓDULO 9: LISTAS 
• Principais métodos para manipulação de listas 
MÓDULO 10: DICIONÁRIOS 
• Conceito 
• Principais métodos para manipulação de dicionários 
MÓDULO 11: MODULOS 
• SYS 
• Instalando módulos 
• From...Import 
• Arquivos byte-compiled .pyc 
MÓDULO 12: BANCO DE DADOS 
• Conexão com banco de dados MySQL 
• Leitura, gravação e alteração 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[7] 
1. APRESENTANDO O PYTHON 
1.1 Como funciona um programa de computador? 
Nossa vida é rodeada de aplicativos. Ao acordarmos um despertador, programado em um smartphone, toca para avisar que é hora 
de acordar; então conferimos o WhatsApp®, Instagram, TikTok® e assim interagimos com o mundo que nos cerca, e não nos resta a 
menor dúvida da essencialidade dos softwares no dia a dia de um jovem na cidade, no campo ou em qualquer lugar no mundo. 
Um programa é o que torna um computador, um smartphone ou tablet num dispositivo utilizável. Sem um programa, um computador, 
mesmo o mais poderoso, nada mais é do que um objeto. Da mesma forma, que sem um pianista, o piano em si, não é nada mais do que 
uma caixa de madeira repleta de cordas e martelos(teclas). 
O fato é que a tecnologia vem moldando a nossa realidade, carros autônomos, computadores de bordo e sensores eletrônicos 
embutidos em veículos, capazes de calcular e analisar a condução do veículo à frente, a presenta de pedestres e animais na estrada, a 
cor de um semáforo. Tudo isso parece muito distante de nossas realidades, mas já é fato. 
Os computadores são capazes de executar tarefas muito complexas, desde que sejam instruídos a fazê-las, mas essa capacidade 
não lhes é inata. A natureza de um computador é bastante diferente, e ele só pode executar operações extremamente simples, como 
um exemplo, um computador não pode avaliar o valor de uma função matemática complicada por si só até o presente momento. 
Computadores contemporâneos só podem avaliar os resultados de operações muito fundamentais, como adicionar ou dividir, mas podem 
fazê-lo muito rapidamente, e podem repetir estas ações virtualmente um grande número de vezes. 
Os softwares existem como o objetivo de resolver os nossos problemas. A boa notícia é que as expectativas são de expansão deste 
setor, pois há uma forte busca das empresas por melhorias em seus processos produtivos e redução de custos. Além disso, cada vez 
mais pessoas estão com acesso a computadores e smartphones. Fatores como esses fazem com que os profissionais da área de 
desenvolvimento de software sejam um dos mais requisitados no mercado de trabalho (BRASSCOM, 2019). 
Antes de pensar em criar os seus próprios aplicativos é preciso compreender alguns conceitos. Um software também pode ser 
conhecido por aplicação ou programa, utilizaremos todas as palavras para nos referir ao mesmo recurso. Mas afinal, o que seria um 
aplicativo ou programa? Segundo o dicionário Oxford Languages, sua definição é: “um programa é concebido para processar 
dados eletronicamente, facilitando e reduzindoEsse problema é mais visualizado quando se utilizam os operadores or e and. 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[83] 
Código com problema: 
 
nome = input("Digite um nome") 
if nome == "Leonardo" or "Gabriel": 
 # escopo da condição 
Código corrigido: 
nome = input("Digite um nome") 
if nome == "Leonardo" or nome == "Gabriel": 
Operadores lógicos escritos em maiúsculo. Os operadores or e and devem ser escritos em minúsculo. 
Código com problema: 
nome = input("Digite um nome") 
if nome == "Leonardo" OR nome == "Gabriel": 
Código corrigido: 
nome = input("Digite um nome") 
if nome == "Leonardo" or nome == "Gabriel": 
Condição sem comparação. As instruções if e elif demandam alguma comparação. 
Código com problema: 
nome = input("Digite um nome") 
if nome == "Leonardo": 
 # escopo do if 
elif: 
 # escopo do elif 
Código corrigido: 
nome = input("Digite um nome") 
if nome == "Leonardo": 
 # escopo do if 
elif nome == "Gabriel": 
 # escopo do elif 
Comparação no else. O else não pode apresentar uma comparação. 
Código com problema: 
nome = input("Digite um nome") 
if nome == "Leonardo": 
 # escopo do if 
else nome == "Gabriel": 
 # escopo do elif 
Código corrigido: 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[84] 
nome = input("Digite um nome") 
if nome == "Leonardo": 
 # escopo do if 
else: 
 # escopo do elif 
3.5 Estrutura switch-case 
O Python em versões anteriores a versão 3.10 não tinha uma estrutura de controle switch-case nativa como outras linguagens, 
mas pode ser simulado comportamento de várias maneiras: Se for testar, usar a IDLE Shell Python, não funciona na Python Sandbox 
3.5.1 Usando um dicionário 
Uma das maneiras mais comuns é usar um dicionário para mapear casos a função ou valores 
def case1(): 
 return "Você escolheu a opção 1!" 
 
def case2(): 
 return "Você escolheu a opção 2!" 
 
def case3(): 
 return "Você escolheu a opção 3!" 
 
def switch(case): 
 switcher = { 
 1: case1, 
 2: case2, 
 3: case3 
 } 
 return switcher.get(case, lambda: "Opção inválida!")() 
 
# Exemplo de uso 
opcao = 3 
resultado = switch(opcao) 
print(resultado) 
 
3.5.2 Usando if-elif-else 
Outra maneira é simplesmente usar as condições if, elif e else 
opcao = int(input(“Escloher de 1 a 3”) 
 
if opcao == 1: 
 print("Você escolheu a opção 1!") 
elif opcao == 2: 
 print("Você escolheu a opção 2!") 
elif opcao == 3: 
 print("Você escolheu a opção 3!") 
else: 
 print("Opção inválida!") 
 
3.5.3 O match-case nas versões de Python 3.10 e superiores 
O comando mach-case foi introduzido no Python a partir da versão 3.10 e teve melhorias em versões subsequentes. A 
estrutura permite fazer correspondências de padrões de maneira mais elegante. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[85] 
Estrutura básica 
A estrutura base do match-case é semelhante a estrutura do switch-case de outras linguagens. A seguir segue um exemplo: 
Opcao=int(input(“selecionar uma opção”)) 
 
match opcao: 
 Case 1: 
 Print(“você escolheu a opção 1!”) 
Case 2: 
 Print(“você escolheu a opção 2!”) 
Case 3: 
 Print(“você escolheu a opção 3!”) 
Case _: 
 Print(“Opção inválida!”) 
 
Entendendo os componentes 
1. match: do inglês corresponder combinar, coincidir com e é exatamente o que o comando faz, inicia uma correspondência 
de padrões, para uma variável que que se deseja avaliar. 
2. case: do inglês, caso, se... um condicional. E é ela quem define cada valor possível, ou cada padrão que estamos tentando 
efetuar correspondências. Ela pode conter vários “cases”, casos, para diferentes valores. 
3. _ (underscore): O underscore já é uma String conhecida nossa, aqui ele funciona como um padrão coringa que captura 
qualquer valor que não corresponda a nenhum dos casos anteriores, não deve ser colocada no início, só no fim, e 
funciona similarmente a um “else”. 
 
Padrões avançados 
Vamos adiantar um pouco de assuntos futuros para entendermos melhor a função. Pois além de valores simples, podemos usar 
padrões mais complexos, como listas, dicionários e objetos 
Correspondência de listas 
entrada = [1, 2, 3] 
match entrada: 
 case [1, 2, 3]: 
 print("A lista contém 1, 2 e 3!") 
 case [1, *resto]: # O '*' captura o restante da lista 
 print(f"A lista começa com 1 e tem mais elementos: {resto}") 
 case _: 
 print("Outro tipo de entrada.") 
 
Correspondência de Dicionários 
dados = {"nome": "Alice", "idade": 30} 
 
match dados: 
 case {"nome": nome, "idade": idade}: 
 print(f"Nome: {nome}, Idade: {idade}") 
 case _: 
 print("Dados não correspondem.") 
 
Correspondência de objetos 
Se estiver usando classes, podemos fazer correspondências de padrões com tributos de classes: 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[86] 
class Pessoa: 
 def __init__(self, nome, idade): 
 self.nome = nome 
 self.idade = idade 
 
pessoa = Pessoa("Bob", 25) 
 
match pessoa: 
 case Pessoa(nome, idade): 
 print(f"Nome: {nome}, Idade: {idade}") 
 case _: 
 print("Não é uma pessoa.") 
 
Benefícios do mach-case 
• Legibilidade: o código se torna mais fácil de ler, especialmente quando você tem muitos casos 
• Expressividade: pode-se fazer correspondências com estruturas de dados complexas de maneira clara e concisa. 
• Flexibilidade: permite capturar grupos de valores e trabalhar com eles diretamente. 
3.6 Instruções break e continue 
As instruções break e continue permitem ao programador um maior controle sobre a quantidade de repetições que são 
executadas. Para entender o funcionamento da instrução break, considere a situação onde desejamos imprimir apenas o primeiro 
número ímpar de uma sequência de números, ignorando a repetição dos demais. Vamos analisar essa situação. Não interessa a execução 
da repetição após encontrarmos o primeiro número ímpar, portanto, é preciso pensar em uma estratégia para interromper a execução 
da repetição. É nesse contexto que o break é utilizado, pois ele permite executar uma repetição antes da condição de parada ser 
estabelecida. Veja a sua aplicação a seguir: 
 
for contador in range(10): 
 if contador % 2 != 0: # Essa condição é verdadeira para números ímpares 
 print(contador) 
 break 
Esse recurso é útil, pois a execução de cada ciclo de repetição apresenta um custo de processamento ao computador. Ainda que 
na maioria dos casos o(a) programador(a) não precise se preocupar com isso, se for possível evitar a execução de ciclos 
desnecessários, a aplicação apresentará uma melhor performance. 
MÓDULO 3: ESTRUTURA CONDICINAL 
• IF, ELIF e ELSE 
• SWITCH CASE 
• BREAK/CONTINUE 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[87] 
3.7 Questões 
1. Qual a sintaxe para representar uma condição em Python? 
2. Em quais situações devemos utilizar condicionantes? 
3. O que é o escopo de uma condição? 
4. Escreva o operador relacional adequado para responder às questões a seguir: 
 ( ) Igualdade 
 ( ) Maior que 
 ( ) Menor que 
 ( ) Diferente 
 ( ) Maior 
 ( ) Menor 
5. Qual o resultado (Verdadeiro ou Falso) das comparações a seguir: 
COMPARAÇÃO RESULTADO 
3 4 
5 > 6 
89 4: 
 print("X é maior que 4") 
else: 
 print("X não é maior que 4") 
7. Escreva um algoritmo que calcula a média de um estudante a partir de duas notas. Deve-se exibir na tela se ele foi aprovado (nota 
maior ou igual a 6) ou reprovado. 
8. Qual o papel dos operadores lógicos em uma condição? 
9. Qual a diferença entre o operador and e or? 
10. Qual a sintaxe da instrução elif?11. Qual será a resposta do algoritmo a seguir? 
saque = 100 
saldo = 30 
valorSacado = 90 
limiteDiario = 200 
if saque = saldo or valorSacado+saque > limiteDiario : 
 print("Saque não pode ser realizado") 
else: 
 print("Nenhuma das ações será executada") 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[88] 
a) Saque realizado 
b) Saque não pode ser realizado 
c) Nenhuma das ações será executada 
12. Qual a diferença entre as instruções elif e else? 
13. O algoritmo a seguir identifica o tipo de um Pokémon a partir de uma entrada. Assim, se a entrada for Pikachu, então deve-se 
apresentar o texto "elétrico"; para o Squirtle, apresenta-se "água" e para o Bulbassauro será exibido o texto "grama". No entanto 
o código apresenta alguns problemas. Faça a sua correção. 
 
pokemon = input("Digite o nome do Pokémon") 
 
if pokemon == "Pikachu": 
 print("elétrico") 
else pokemon == "Squirtle": 
 print("água") 
elif: 
 print("grama") 
14. Crie um algoritmo que vai ler um número inteiro do teclado e indicar se ele é positivo, negativo ou igual a zero. Essa informação 
deve ser apresentada na tela. 
	Prof.: André Andrade
	I. EMENTA
	II. OBJETIVOS GERAIS
	III. OBJETIVOS ESPECÍFICOS
	IV. COMPETÊNCIAS
	V. CONTEÚDO PROGRAMÁTICO
	MÓDULO 1: APRESENTANDO O PYTHON
	MÓDULO 2: OPERADORES, EXPRESSÕES E VARIÁVEIS
	MÓDULO 3: ESTRUTURA CONDICINAL
	MÓDULO 4: ESTRUTURA DE REPETIÇÃO
	MÓDULO 5: FUNÇÕES
	MÓDULO 6: STRINGS E ARQUIVOS
	MÓDULO 7: MATRIZES
	MÓDULO 8: ESTRUTURA DE DADOS
	MÓDULO 9: LISTAS
	MÓDULO 10: DICIONÁRIOS
	MÓDULO 11: MODULOS
	MÓDULO 12: BANCO DE DADOS
	1. APRESENTANDO O PYTHON
	1.1 Como funciona um programa de computador?
	1.2 Linguagens naturais vs. linguagens de programação
	Paradigma
	1.3 O que faz uma linguagem?
	1.4 Entrada e Saída de Dados
	1.5 Interpretadores
	Funcionamento:
	Vantagens
	Desvantagens
	Exemplos de Linguagens Interpretadas
	1.6 Compiladores
	Funcionamento
	Exemplos:
	Vantagens
	Desvantagens
	Exemplos de Compiladores
	1.7 Compilação vs. Interpretação
	Similaridades
	Diferenças
	Exemplos
	1.8 O que é que o intérprete realmente faz?
	E o que significa tudo isto em si?
	1.9 O que é o Python?
	Quem criou o Python?
	O que torna o Python especial?
	É claro que o Python também tem os seus inconvenientes:
	Um projeto de programação de hobby
	Objetivos do Python
	1.10 INSTALAÇÃO DO PHYTON
	PRIMEIRO ESCOLHA O SISTEMA QUE VAI INSTALAR E BAIXE O APLICATIVO
	EM WINDOWS
	EM LINUX
	Debian e Ubuntu
	RedHat e CentOS
	Instalação por repositório
	EM Mac OS X
	Instalação do zero
	1.11 Como escrever e executar o seu primeiro programa
	Escrevendo um programa:
	Como estragar e corrigir o seu código
	1.12 Questões
	1. O que são aplicativos?
	2. Cite dois exemplos de dispositivos de entrada e saída para o computador.
	3. O que é a sintaxe de uma linguagem de programação?
	4. O que são algoritmos de computação e quais as regras existentes para a sua criação?
	5. Para que utilizamos as instruções em programação?
	6. Por que a programação é uma importante área para a nossa sociedade atual?
	7. Por que precisamos da linguagem de programação?
	8. Phyton é um exemplo de:
	9. Um conjunto completo de comandos conhecidos é chamado de:
	10. O que é um source code?
	11. Como se chama um programa de computador que executa diferentemente instruções escritas numa linguagem de programação?
	12. Qual a versão de Phyton abordaremos?
	13. O que é CPython?
	14. O que é IDLE do Python?
	15. Como se chama uma ferramenta que lhe permite lançar o seu código passo a passo e interpretá-lo em cada momento da exrcução?
	16. Como é que o Python, a linguagem de programação, recebeu o seu nome?
	17. Qual dos seguintes é um exemplo de extensão de um arquivo Python?
	18. O que é código de máquina?
	19. Como se chama um intérprete de linha de comando que lhe permite interagir com o seu sistema operativo, e executar comandos e scripts de Python?
	20. Qual é o componente esperado do seguinte programa?
	21. Como se chama um arquivo que contém um programa escrito numa linguagem de programação de alto nível?
	22. Quais são os quatro elementos fundamentais que fazem uma linguagem?
	23. Qual é o componente esperado do seguinte programa?
	24. O que é CPython?
	25. Colocar V ou F:
	Compiladores
	Interpretadores
	Aspecto
	2. Operadores, expressões e variáveis
	Entender corretamente o problema que será trabalhado é fundamental para construir uma solução adequada. Infelizmente, muitos aprendizes falham nessa etapa e como consequência criam programas incorretos. Felizmente, existem estratégias que ajudam na re...
	2.1 Etapas para a solução de um problema
	2.1.1 Entendendo o problema
	2.1.2 Caracterizar o problema
	2.1.3 Representar o problema
	2.1.4 Resolver o problema
	2.1.5 Refletir sobre a solução
	2.2 Variáveis
	2.2.1 Dados que nos cercam dia a dia
	Tabela02 – Tabela Variavel x dado armazenado
	2.2.2 Estrutura de uma variável
	Tabela03 -Tabela de Associações Etiqueta x Dado
	2.2.3 Criando variáveis em Python:
	2.2.4 Modificando o dado de uma variável
	2.2.5 Recuperando dados
	2.2.6 Variáveis numéricas
	2.2.7 Variáveis que armazenam palavras/textos (Strings)
	2.2.8 Variáveis Booleanas
	Perguntas e respostas
	Comparação: com o operador de igualdade:
	Desigualdade: operador não igual a (!=)
	Operadores de desigualdade: > (maior que); >= (maior ou igual a), (diferente de)
	E o que fazer com o uso das respostas?
	2.2.9 Tipos de dados
	Literal
	Inteiros
	Números octais e hexadecimais
	Floats
	Codificação de floats
	2.2.10 Operações Matemáticas
	Operadores e suas ligações
	Lista de prioridades:
	Tabela10 -tabela de prioridades completa
	Operadores de parêntesis
	Operadores de atalho
	2.2.11 Armazenamento das variáveis no computador
	2.2.12 Os erros mais comuns
	2.3 Algumas funções no Python
	2.3.1 print()
	De onde vem as funções?
	caráteres de escape e de newline
	Argumentos de Keyword
	2.3.1.1 Deixar comentários em código: por quê? como? e quando?
	2.3.2 Input()
	A função input() com um argumento
	Type casting
	Conversão de tipo: str()
	2.4 Por que precisamos de entrada e saída de dados?
	2.4.1 Entrada de dados
	2.5 Tipos de conversão de dados
	Comando f-string
	2.6 Erros na programação
	2.6.1 Erro de sintaxe
	2.6.2 Interpretando mensagens de erro
	2.6.3 Categorias de erros de sintaxe
	SyntaxError(indica o uso incorreto da sintaxe)
	NameError(declaração incorreto de variáveis. Também ocasionados por violação de sintaxe)
	TypeError(na realização de operações entre variáveis que são de tipos diferentes)
	2.7 Localizando um erro
	2.8 Erros lógicos
	Erros muito comuns
	2.9 Questões
	1. O que são variáveis na programação?
	2. Por que as variáveis recebem esse nome?
	3. O que aconteceria se não fosse possível armazenar dados em um programa?
	4. Assinale com V (verdadeiro) ou F (falso) as afirmações a seguir:
	5. Quais nomes de variáveis estão INADEQUADOS?
	6. Imagine que você deseja armazenar o nome de uma pessoa em uma variável, qual seria um bom nome para ela?
	7. Por que as variáveis precisam de um nome?
	8. A declaração de uma variável é composta por três partes, quais são elas?
	9. Assinale V ou F para as afirmações a seguir:
	10. Explique como o computador lê o nosso algoritmo.
	11. Declare duas variáveis, uma com número inteiro e outra com um número decimal.
	12. Como representar variáveis que guardam os números percentuais a seguir: 30%, 5%, 75% e 6.5%.
	13. Qual o problema nos código a seguir:
	14. O que variáveis do tipo String armazenam?
	15. Para declarar uma variável String devemos colocar o valor entre:
	16. Declare uma variável para representar o valor do seguinte texto: Estou lendo um livro de introdução à programação.
	17. Qual o operador utilizado para concatenar textos?
	18. Por que utilizamos o operador de concatenação?
	19. Realize a concatenação de duas variáveis do tipo texto. Você pode definir os valores que achar mais adequado.
	20. Quais sãoos valores que uma variável booleana pode possuir?
	21. Em quais situações nós usamos variáveis booleanas?
	22. Marque com V ou F as situações a seguir que podem ser representadas como booleanas:
	23. Escreva os operadores matemáticos utilizados no Python para realizar as seguintes operações matemáticas:
	24. Qual a importância dos operadores matemáticos para a programação?
	25. Qual é o valor da variável pontuação após a execução do algoritmo?
	26. Qual será o valor de x após a execução do algoritmo?
	27. O algoritmo a seguir possui um erro, pois não calcula corretamente uma média. O que é necessário para corrigi-lo?
	28. O que são os operadores de atribuição compostos e quais os benefícios em utilizá-los?
	29. Considere um algoritmo com duas variáveis, sendo um número par e outro ímpar. Qual operador poderia ser utilizado para descobrir quem é o par e quem é o ímpar?
	30. Usando os argumentos sep e end, qual a função que produziria esse resultado na tela: Programação*** Essencial***em...Python
	31. Que tipos de literais são os dois exemplos seguintes?
	32. Que tipos de literais são os quatro exemplos seguintes?
	33. Qual é o valor decimal do seguinte número binário, como programar no Python?
	34. Desenhe um quadrado usando a função print() use os símbolos + para os cantos, - para as arestas horizontais, | para as arestas verticais. Faça com 12 caracteres horizontais e 6 verticais. O código tem que ter no máximo 3 linhas. Ao terminar dupliq...
	35. O exemplo do programa gera uma seta: pede-se
	36. Escreva um Código de uma linha com a função print(), caracteres newline e de escape, para corresponder ao resultado de três linhas.
	37. Numa operação matemática, obtenha o valor inteiro das divisões e o resto, coloque em uma única linha de programação para: 14 dividido por 4
	38. Qual é o output do seguinte código?
	39. Qual é o output do seguinte código?
	40. Qual é o output do seguinte código?
	41. Construir um programa curto que resolva problemas matemáticos simples, como o teorema de Pitágoras: o quadrado da hipotenusa é igual a soma do quadrado dos catetos. Considerem o comprimento da hipotenusa (o lado mais longo do triangulo) usando o t...
	42. Uma vez em Appleland, o John tinha três maçãs, a Mary tinha cinco maçãs, e o Adam tinha seis maçãs. Todos eles foram muito felizes e viveram durante muito tempo. Fim da história.
	43. Milhas e quilómetros são unidades de comprimento ou distância. Tendo em mente que 1 milha é aproximadamente igual a 1.61 quilómetros, complete o programa no editor para que ele converta:
	44. Veja o código no editor: ele lê um valor float , coloca-o numa variável chamada x, e imprime o valor de uma variável chamada y. A sua tarefa é completar o código para avaliar a seguinte polinômio: 3x3-2x2+3x-1 , o resultado deve ser atribuído a y.
	45. Qual é o output do seguinte código?
	46. Quais dos seguintes nomes de variáveis são inválidos em Python?
	47. Qual é o output do seguinte snippet?
	48. Qual é o output do seguinte snippet?
	49. O código no editor contém comentários. Tente melhorá-lo: adicione ou remova comentários onde achar apropriado (sim, por vezes remover um comentário pode tornar o código mais legível), e altere nomes de variáveis onde achar que isso irá melhorar a ...
	50. Qual é o output do seguinte snippet?
	51. O que acontecerá quando executar o seguinte código?
	52. Sua tarefa é completar o código a fim de avaliar os resultados de quatro operações aritméticas básicas. Os resultados têm de ser impressos para a consola. Poderá não conseguir proteger o código de um utilizador que queira dividir por zero. Tudo be...
	53. (Intermediário)Familiarizar-se com o conceito de números, operadores e operações aritméticas em Python; compreender a precedência e associatividade dos operadores Python, bem como o uso adequado de parêntesis.
	54. (Intermediario)A sua tarefa é preparar um código simples capaz de avaliar o tempo final de um período de tempo, dado como um número de minutos (pode ser arbitrariamente grande). O tempo inicial é dado como um par de horas (0.. 23) e minutos (0.. 5...
	55. Qual é o output do seguinte snippet?
	56. Qual é o output do seguinte snippet?
	57. Calculando Rendimentos
	58. Leia os códigos a seguir e indique qual tipo de erro de sintaxe (SyntaxError, NameError e TypeError) eles apresentam:
	59. O código a seguir foi construído para calcular uma média. Há algum problema? Se sim, qual seria a sua correção?
	60. Analise a mensagem de erro a seguir e identifique as suas partes: trecho do código com problema, sua linha, o tipo de erro e a mensagem específica do erro.
	61. Assinale Verdadeiro (V) ou Falso (F) para as afirmações:
	62. Crie um algoritmo para realizar a leitura de um dado e o armazene em uma variável.
	63. Crie um algoritmo para realizar a leitura de um dado, informando ao usuário sobre o que ele precisa digitar.
	64. Crie um algoritmo para realizar a leitura de dois textos do teclado e faça a sua concatenação.
	65. Assinale Verdadeiro ou Falso para as afirmações:
	66. Crie um algoritmo para realizar a leitura de um dado e o converta para inteiro.
	67. O algoritmo de calculadora abaixo está incompleto, pois não apresenta o resultado da operação na tela do usuário. Escreva a instrução necessária para realizar esse procedimento:
	68. Usando um dos operadores de comparação em Python, escreva um programa simples de duas linhas que toma o parâmetro n como input, que é um inteiro, e imprime False Se n for menor que 100, e True Se n for maior ou igual que 100. Não use nenhum coman...
	3. Estrutura Condicional
	3.1 Sintaxe para a criação das condições
	3.2 Representando uma condição – operador if
	As primeiras linhas do código estão fora do escopo da condição e por isso serão executadas independente do resultado da comparação. Observe na terceira linha como combinamos o uso das instruções int e input, isso é possível na programação. O Python va...
	Esse procedimento é necessário, pois na comparação da condição estamos interessados em saber se um número é menor ou igual ao outro. Na sequência, estão as instruções que fazem parte do escopo da condição e somente serão executadas a depender do valor...
	A seguir apresentamos alguns cenários para esse exemplo e o que seria apresentado na tela em cada um deles:
	3.3 Operadores relacionais junto a função if
	Menor queo Bulbassauro será exibido o texto "grama". No ...
	14. Crie um algoritmo que vai ler um número inteiro do teclado e indicar se ele é positivo, negativo ou igual a zero. Essa informação deve ser apresentada na tela.o tempo de execução de uma tarefa pelo usuário.” (SILVA & FORTES, 2022) 
Imagine que se queira saber a velocidade média que alcançou durante uma longa viagem. Sabe-se a distância percorrida, a duração 
de tempo, e agora precisamos calcular a velocidade média 𝑣𝑣𝑚𝑚 . 
Naturalmente, um computador é capaz de calcular isto, é um cálculo relativamente simples, entretanto o computador não está 
ciente de coisas como distância, velocidade ou noção de tempo. Portanto, é necessário que alguém instrua o computador a: 
• aceitar um número que represente a distância; 
• aceitar um número que represente o tempo de viagem; 
• dividir o valor anterior pelo último e armazenar o resultado na memória; 
• exibir o resultado (representando a velocidade média) num formato legível. 
Estas quatro simples ações formam um programa. É claro que o exemplo supracitado não está formalizado, é uma espécie de 
algorítimo1, e estão muito longe do que o computador pode compreender, mas são suficientemente bons para serem traduzidos para 
uma linguagem que o computador possa aceitar. 
Agora se imagine como um programador de um jogo de atirar como o Fortnite, e você precise superar alguns obstáculos para 
poder fazer com que um tiro no jogo com uma arma qualquer possa ocorrer. Para nos auxiliar precisamos escrever um algorítimo 
estruturado simplificado para que possamos nos focar em cada tarefa, que é realizada por um conjunto de ações: 
1. Identificar quando o clique no mouse ocorrer; 
2. Diminuir uma bala; a cada bala que sair da arma; 
 
1 Algoritmo - forma de estruturar as ações necessárias para alcançar um determinado objetivo. 
𝑣𝑣𝑚𝑚 =
∆𝑠𝑠
∆𝑡𝑡 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[8] 
3. Verificar se o inimigo foi atingido; 
4. Diminuir a saúde do inimigo. 
Um dos papeis do programador é a identificação das ações que devem ser realizadas para uma determinada funcionalidade criada. 
A este processo damos o nome de Pensamento Algorítmico e envolve os passos: 
• Compreender o problema que se espera resolver; 
• Subdividir o problema em partes menores e mais simples; 
• Escrever as instruções para resolver o problema de cada uma das subpartes do problema inteiro; 
Para o dia a dia, vamos escrever um algoritmo que nos auxilie na troca de uma lâmpada: 
1. Comprar uma lâmpada compatível com a que irá ser trocada; 
2. Montar a escada; 
3. Subir na escada; 
4. Retirar a lâmpada queimada; 
5. Colocar a nova lâmpada 
6. Descer da escada; 
7. Testar se a nova lâmpada está funcionando 
O conjunto de ações acima são de 7 ações em forma sequencial, uma após a outra e qualquer alteração na ordem irá comprometer 
o resultado. Por exemplo: pastando trocar os passos 2 e 3; 
1. Comprar uma lâmpada compatível com a que irá ser trocada; 
2. Subir na escada; (NÃO CONSIGO EXECUTAR ESSA TAREFA PORQUE ESTÁ FORA DA ORDEM) 
3. Montar a escada; 
Como eu posso subir na escada sem antes montar a escada para, é impossível! O que impede que a tarefa de se trocar uma simples 
lâmpada não possa ocorrer. O que de forma prática algoritmo computacional é a representação passo a passo de como resolver um 
problema proposto. É de suma importância que diante de um problema, nós o estudemos, o dissequemos e o quebremos em pedaços 
menores, e se esses pedacinhos puderem ser quebrados mais ainda, o façamos para que possamos resolver todos os pequenos 
problemas e gerar a solução da completude do problema como um todo. 
Saber conceitos é ESSENCIAL, para que possamos pensar nas ações de forma sequencial e poderão serem materializados pelo 
programador através de instruções. E como se pode observar, um programa é formado por palavras, e como em um livro, que temos 
que ler sequencialmente na ordem que foram escritas, o computador também executa o código de programação de forma sequencial, 
lendo cada comando e cada linha, executando cada ação de cima para baixo, da esquerda para direita, entende os desvios e executa 
tudo da forma que o programador planejou. 
Linguagem: (Language) é a palavra-chave. 
1.2 Linguagens naturais vs. linguagens de programação 
Uma linguagem é um meio (e uma ferramenta) para expressar e registar pensamentos. Há 
muitas linguagens ao nosso redor. Algumas delas não requerem nem a fala nem a escrita, como a 
linguagem corporal; é possível expressar os seus sentimentos mais profundos com muita precisão 
sem dizer uma palavra. 
Outra linguagem que usa diariamente é a sua língua materna, que usa para manifestar a sua 
vontade e para pensar na realidade. Os computadores também têm a sua própria linguagem, chamada 
linguagem de máquina, que é muito rudimentar. 
Um computador, mesmo o mais sofisticado tecnicamente, é desprovido até mesmo de um vestígio de inteligência. Pode-se dizer 
que é como um cão bem treinado - responde apenas a um conjunto pré-determinado de comandos conhecidos. 
Os comandos que reconhece são muito simples. Podemos imaginar que o computador responde a ordens como "pega nesse número, 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[9] 
divide-o por outro e guarda o resultado". 
Um conjunto completo de comandos conhecidos é chamado de lista de instruções, por vezes abreviado para IL (do inglês, 
Instruction List). Os diferentes tipos de computadores podem variar em função do tamanho das suas IL, e as instruções podem ser 
completamente diferentes em diferentes modelos. 
Nota: as linguagens de máquina são desenvolvidas por humanos. 
Atualmente, nenhum computador é capaz de criar uma nova linguagem. No entanto, isso pode mudar em breve. Por outro lado, as 
pessoas também utilizam uma série de línguas muito diferentes, mas estas línguas desenvolveram-se naturalmente. Além disso, ainda 
estão a evoluir. 
Cria-se novas palavras todos os dias e as palavras antigas desaparecem. Estas línguas são chamadas linguagens naturais. 
Paradigma 
O paradigma de suma importância na programação pela organização do Código, o que ajuda a estruturá-lo de maneira eficiente, 
facilita a manutenção, já que códigos bem-organizados são mais fáceis de entender e de se modificar e principalmente pela Reutilização, 
e uma boa estruturação, e organização de um código permite a criação de componentes reutilizáveis, economizando tempo e esforço. 
No dicionário Michaelis, um Paradigma é algo, que serve de exemplo ou modelo, um padrão, e linguisticamente é um conjunto de 
termos comutáveis entre si, em uma mesma posição, numa estrutura. Já um paradigma de programação é um estilo ou abordagem 
que orienta a construção de programas e a resolução de problemas. Ele define as maneiras como os desenvolvedores pensam sobre a 
estrutura e o comportamento do código. Os Principais tipos são: 
1- Programação Imperativa, com foco na realização de tarefas, usando comandos sequenciais de fluxo (como loops e condicionais) 
usados em C, Java e Python. 
2- Programação Declarativa: Foca no que deve ser feito, em vez de como deve ser feito. O programador descreve o resultado 
desejado, amplamente usados em SQL e Prolog; 
3- Programação Orientada a Objetos (POO): É baseada em dados e comportamento encapsulados por objetos 0. O que promove a 
reutilização de código por meio de herança e polimorfismo, muito usados em Java, C++ e Ruby.; 
4- Programação Funcional – que trata a computação como a avaliação de funções matemáticas, e evita os efeitos colaterais e os 
estados mutáveis, como exemplo as linguagens Haskell, Scala e Lisp. e 
5- Programação Lógica – que é baseada na lógica formal, onde os programas são expressos em termos de declarações lógicas e o 
sistema resolve consultas, como exemplo a linguagem Prolog. 
1.3 O que faz uma linguagem? 
Podemos dizer que cada linguagem (de máquina ou natural, não importa) é constituída pelos seguintes elementos: 
• um alfabeto: um conjunto de símbolos utilizados para construir palavras de uma determinada linguagem (por exemplo, o 
alfabeto latino para inglês, o alfabeto cirílico para russo, o Kanji para japonês etc.) 
• um léxis: (ou seja,um dicionário) um conjunto de palavras que a linguagem oferece aos seus utilizadores (por exemplo, a 
palavra "computador" vem do dicionário de língua inglesa, enquanto que "cmoptrue" não; a palavra "chat" está presente 
tanto nos dicionários de inglês como de francês, mas os seus significados são diferentes) 
• uma sintaxe: um conjunto de regras (formais ou informais, escritas ou sentidas intuitivamente) utilizadas para determinar 
se uma determinada sequência de palavras forma uma frase válida (por exemplo, "Eu sou uma píton" é uma frase 
sintaticamente correta, enquanto "Eu uma piton sou" não é) 
• semântica: um conjunto de regras que determinam se uma determinada frase faz sentido (por exemplo, "Comi um donut" 
faz sentido, mas "Um donut comeu-me" não faz) 
O IL é, de facto, o alfabeto de uma linguagem de máquina. Este é o conjunto mais simples e primário de símbolos que podemos 
utilizar para dar comandos a um computador. É a língua materna do computador. 
Infelizmente, esta língua está muito longe de ser uma língua materna humana. Todos nós (tanto computadores como humanos) 
precisamos de algo mais, uma linguagem comum para computadores e humanos, ou uma ponte entre os dois mundos diferentes. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[10] 
Precisamos de uma linguagem em que os humanos possam escrever os seus programas e uma linguagem que os computadores 
possam utilizar para executar os programas, uma linguagem que seja muito mais complexa do que a linguagem das máquinas e, no 
entanto, muito mais simples do que a linguagem natural. 
Tais linguagens são muitas vezes chamadas linguagens de programação de alto nível. São pelo menos um pouco semelhantes aos 
naturais na medida em que utilizam símbolos, palavras e convenções legíveis para os seres humanos. Estas linguagens permitem aos 
seres humanos expressarem comandos a computadores que são muito mais complexos do que os oferecidos pelas IL. 
Um programa escrito numa linguagem de programação de alto nível é chamado source code 2(em contraste com o machine code3 
executado por computadores). Da mesma forma, o arquivo que contém o source code chama-se source file4. 
1.4 Entrada e Saída de Dados 
O algoritmo geralmente necessita de uma informação para poder iniciar o seu processamento (execução de instruções). Esta 
informação é chamada de entrada. Esta pode ser um clique de mouse, um número que determina a distância entre o ponto A e o ponto 
B, ou qualquer informação que irá desencadear os demais conjuntos de instruções. 
Outro conceito importante que são produzidos pelos algoritmos são os conceitos de saída. Esa é o resultado obtido após o término 
da execução de todas as instruções projetadas para acontecer pelo programador. Pode ser uma imagem, um som, um valor em resposta 
a um cálculo. 
É muito importante entendermos o conceito de entrada, processamento e saída. 
“PROGRAMAS PROCESSAM ENTRADAS QUE RESULTAM SAÍDAS” 
Ex. Um carro parte da cidade A para a cidade B, calcule a Vm? Sabendo que a distância entre as cidades é 390 Km e que o carro 
demorou 4 h 52’ 30”. 
 
 
 
FIG. 01 -CAIXA PRETA DO PROGRAMA DE FUNÇÃO VELOCIDADE MÉDIA 
 
 
 
FIG. 02 -CAIXA PRETA DO PROGRAMA, COM EXPLANAÇÃO DO QUE O PROGRAMA DEVE FAZER, AO RECEBER DADOS DE TEMPO E DISTÂNCIA 
1.5 Interpretadores 
O interpretador é um tipo de programa intérprete que executa código fonte, traduzindo-o linha por linha, em tempo real, sem a 
necessidade de compilação prévia. Isso permite que os desenvolvedores testem e modifiquem seu código rapidamente. 
Funcionamento: 
Os interpretadores funcionam através de um processo que inclui: 
 
2 Source code – Código-fonte - Conjunto de códigos escritos pelo programador que não pode ser executado diretamente 
pelo computador, mas tem de ser traduzido em um programa de código-objeto por um compilador ou interpretador. 
3 Machine Code – Código de Máquina é a sequência de bytes que correspondem a instruções a serem executadas pelo 
processador. 
4 Source file – Arquivo fonte é o arquivo que contém o código fonte armazenado. 
PROGRAMA 
∆𝑡𝑡 
∆𝑠𝑠 
𝑣𝑣𝑚𝑚 
𝒗𝒗𝒎𝒎 =
∆𝒔𝒔
∆𝒕𝒕 
∆𝑡𝑡 = 4 h 52’ 30” 
∆𝑠𝑠= 390 km 
𝑣𝑣𝑚𝑚= 80 Km/h 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[11] 
1. Leitura: O código fonte é lido. 
2. Análise: O código é analisado para verificar sua sintaxe e semântica. 
3. Execução: O código é executado diretamente, instrução por instrução. 
Vantagens 
• Portabilidade: O código pode ser executado em qualquer plataforma que tenha o interpretador adequado. 
• Facilidade de Debugging5: Como o código é executado linha por linha, é mais fácil identificar e corrigir erros. 
• Interatividade: Muitos interpretadores permitem a execução interativa, tornando o desenvolvimento mais dinâmico. 
Desvantagens 
• Desempenho: Em geral, programas interpretados são mais lentos que os compilados, pois é feita tradução em tempo real. 
• Dependência do Interpretador: O código não pode ser executado sem o interpretador correspondente. 
Exemplos de Linguagens Interpretadas 
• Python (Ideal para desenvolvimento web, ciência de dados e automação.) 
• Node.js (JavaScript) (Amplamente utilizado para desenvolvimento de servidores e aplicações) 
• Ruby MRI (Matz's Ruby Interpreter) (Usado principalmente em desenvolvimento web com o framework Ruby on Rails.) 
• PHP (Comum em aplicações dinâmicas e sistemas de gerenciamento de conteúdo.) 
• R (Usado em ciência de dados e pesquisa estatística.) 
• Perl (Usado em administração de sistemas e desenvolvimento web.) 
Interpretadores desempenham um papel muito importante, diria até essencial, no desenvolvimento de software, já oferecem 
maneiras flexíveis, e muitas vezes, interativas de se escrever e executar um código. Apesar das desvantagens em termos de 
desempenho, seu uso é amplamente aceito em diversas áreas de programação. E para cada tipo de aplicação, é usado uma linguagem 
de programação, já que cada linguagem tem características próprias, sintaxes específicas e paradigmas 
1.6 Compiladores 
São programas que traduz código fonte escrito em uma linguagem de programação de alto nível para uma linguagem de baixo nível, 
geralmente código de máquina6 ou bytecode7, que podem ser diretamente executados pelo sistema operacional ou por máquina virtual. 
 
5 Bug e Debugging – Bug do inglês é inseto, o termo “bug” já era utilizado na engenharia e na mecânica antes de ser aplicado 
à computação. E se referia a defeitos e falhas em máquinas. Em 1947 (Na era eletrônica de 1940 aos dias atuais) a equipe de 
engenheiros no Harvard Mark II encontraram uma mariposa presa em um relé da máquina, que causava um mau 
funcionamento, o evento foi documento em um caderno e intitulado de: “O primeiro caso real de um bug.”, desde então a 
palavra passou a descrever qualquer falha ou comportamento indesejado em um software ou hardware, virando um jargão 
da indústria tecnológica. Já o Debugging é o processo de se identificar e corrigir bugs em software, o termo reflete a prática 
de remover erros ou “bugs” no código. 
6 Linguagem de máquina: é o conjunto de instruções que um computador pode entender e executar diretamente. Essas 
instruções são compostas de números binários (0s e 1s) correspondentes a operações básicas que o processador pode 
realizar. Caracterizada por: Binária: Composta por uma sequência de bits; Específica do Processador: Cada tipo de CPU 
tem seu próprio conjunto de instruções; e Baixo Nível: O que oferece um controle detalhado sobre o hardware, mas de 
compreensão extremamente difícil de leitura por humanos. Mas que apresenta ótimas Vantagens de Desempenho, já que 
o código é altamente otimizado para o hardware específico e de Controle, o que permite a manipulação direta dos recursos 
do sistema, ou seja, não precisa ser interpretada e atua diretamente no periférico. As Desvantagens são a Complexidade, 
já que é difícil de se entender e é propensa a erros, e a Portabilidade, não é fácil transferir entre diferentestipos de hardware. 
O uso da linguagem de máquina é geralmente gerado por compiladores a partir do código-fonte escrito em linguagem de alto 
nível, como C, Java ou Python. 
7 Bytecode: conjunto intermediário de instruções que é executado por uma máquina virtual (MV), como a Java Virtual 
Machine (JVM) ou o Python Virtual Machine (PVM). Sendo gerado a partir do código-fonte por um compilador e não é 
específico de hardware, o que o torna portátil entre diferentes sistemas. Característica como: Portabilidade: qualquer 
plataforma que tenha a MV correspondente pode executá-lo; Intermediário: Está entre o código-fonte de alto nível e a 
linguagem de máquina, o que é melhor entendível que a Linguagem de Máquina; Eficiência: Muito mais rápido de ser 
interpretado que um código-fonte diretamente. As Vantagens são a de Independência de Plataforma, já que o mesmo 
bytecode pode rodar diretamente em diferentes sistemas operacionas e a Segurança, pois a execução em uma MV pode 
oferecer um ambiente controlado. Exemplos: Java: código é compilado em bytecode que roda na JVM. Phyton: O código é 
compilado em bytecode que é executado pela PVM. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[12] 
Funcionamento 
Etapas de um processo de compilação: 
1. Análise Léxica: O código fonte é dividido em tokens, que são as unidades básicas de significado. 
2. Análise Sintática: Tokens são organizados em estrutura hierárquica (árvore sintática) e representa a gramática do código. 
3. Análise Semântica: Verifica-se a estrutura sintática faz sentido em termos de regras da linguagem, como tipos de dados. 
4. Geração de Código: O compilador gera código de máquina ou bytecode a partir da árvore sintática. 
5. Otimização: O código gerado pode ser otimizado para melhorar o desempenho. 
6. Geração de Código de Saída: O código final é escrito em um arquivo executável ou bytecode. 
Exemplos: 
 
FIG. 03 -EXEMPLO DE UM CÓDIGO FONTE EM PHYTON 
 
FIG. 04 -EXEMPLO DE UM BYTECODE 
 
FIG. 05 -EXEMPLO DE UM PROGRAMA EM LINGUAGEM DE MÁQUINA PARA PROCESSADOR X86-64 
Vantagens 
• Desempenho: O código compilado geralmente é mais rápido na execução, pois já está traduzido para código de máquina. 
• Detecção de Erros: Erros de sintaxe e semântica podem ser detectados durante a compilação, antes da execução do 
programa, ou seja, o código de máquina debuga os compiladores. 
• Otimização: Compiladores podem aplicar várias técnicas de otimização para melhorar a eficiência do código gerado. 
Desvantagens 
• Tempo de Compilação: O processo de compilação pode ser demorado, especialmente para projetos grandes. 
• Portabilidade: O código compilado é geralmente específico para uma plataforma; recompilações são necessárias para 
outras plataformas. 
• Feedback Lento: O feedback sobre erros só é fornecido após a compilação completa. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[13] 
Exemplos de Compiladores 
• GCC (GNU Compiler Collection): Para linguagens como C e C++. 
• Clang: Um compilador para C, C++ e Objective-C. 
• javac: O compilador da linguagem Java, que gera bytecode executado por uma JVM. 
• Rustc: O compilador para a linguagem Rust. 
1.7 Compilação vs. Interpretação 
Similaridades 
1. Objetivo: Ambos têm o objetivo de traduzir código fonte escrito em uma linguagem de alto nível para uma forma que possa 
ser executada pelo computador. 
2. Processo de Tradução: Tanto interpretadores quanto compiladores analisam o código fonte para verificar a sintaxe e 
semântica. 
3. Linguagens de Programação: Ambos podem ser usados para diversas linguagens de programação, embora algumas 
linguagens sejam predominantemente interpretadas ou compiladas. 
Diferenças 
Aspecto Interpretadores Compiladores 
Execução Executa o código linha por linha em tempo real. 
Traduz o código fonte inteiro para um arquivo 
executável antes da execução. 
Desempenho 
Geralmente mais lento, pois traduz o código em tempo 
real. 
Normalmente mais rápido após a compilação, pois o 
código já está traduzido. 
Feedback 
de Erros 
Fornece feedback imediato sobre erros de sintaxe. Mostra erros apenas após a compilação completa. 
Portabilidade 
O código pode ser executado em qualquer sistema 
com o interpretador. O código compilado é específico para uma plataforma. 
Tipo de Saída 
Não gera um arquivo executável; executa 
diretamente. Gera um arquivo executável separado. 
TAB. 01 -TABELA DAS DIFERENÇAS EM RELAÇÃO AOS COMPILADORES E INTERPRETADORES 
Exemplos 
• Interpretadores: Python, Ruby, JavaScript (Node.js) 
• Compiladores: C, C++, Java (compilado para bytecode, executado por uma JVM) 
1.8 O que é que o intérprete realmente faz? 
Vamos assumir mais uma vez que escreveu um programa. Agora, existe como um arquivo de computador: um programa de 
computador é na realidade um pedaço de texto, por isso o source code é normalmente colocado em arquivos de texto. 
Nota: tem de ser puro texto, sem quaisquer decorações como diferentes fontes, cores, imagens embutidas ou outros suportes. 
Agora tem de invocar o intérprete e deixá-lo ler o seu source file. 
O intérprete lê o source code de uma forma que é comum na cultura ocidental: de cima para baixo e da esquerda para a direita. 
Há algumas exceções. 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[14] 
Em primeiro lugar, o intérprete verifica se todas as linhas subsequentes estão corretas (utilizando os quatro aspetos abordados 
anteriormente no item 1.3 O que faz uma linguagem?). 
Se o compilador encontrar um erro, termina o seu trabalho imediatamente. O único resultado, neste caso, é uma mensagem de 
erro. 
O intérprete irá informar onde se encontra o erro e o que o causou. No entanto, 
estas mensagens podem ser enganadoras, uma vez que o intérprete não é capaz de 
seguir exatamente as suas intenções, e pode detectar erros a alguma distância das 
suas verdadeiras causas. 
Por exemplo, se tentar utilizar uma entidade com um nome desconhecido, causará 
um erro, mas o erro será descoberto no local onde tenta utilizar a entidade, e não 
onde o nome da nova entidade foi introduzido. De outra forma, a razão real está 
normalmente localizada um pouco mais cedo no código, por exemplo, no local onde 
teve de informar o intérprete de que ia utilizar a entidade do nome. 
Se a linha parecer boa, o intérprete tenta executá-la (nota: cada linha é normalmente executada separadamente, pelo que o trio 
"read-check-execute" pode ser repetido muitas vezes - mais vezes do que o número real de linhas no source file, uma vez que algumas 
partes do código podem ser executadas mais de uma vez). 
É também possível que uma parte significativa do código possa ser executada com sucesso antes de o intérprete encontrar um 
erro. Este é um comportamento normal neste modelo de execução. 
Pode perguntar agora: o que é melhor? O modelo "compilador" ou o modelo "intérprete"? Não há uma resposta óbvia. Se houvesse, 
um destes modelos já teria deixado de existir há muito tempo. Ambos têm as suas vantagens e as suas desvantagens. 
E o que significa tudo isto em si? 
O Python é uma linguagem interpretada. Isto significa que herda todas as vantagens e desvantagens descritas. Naturalmente, 
acrescenta algumas das suas características únicas a ambos os conjuntos. 
Se quiser programar em Python, precisará do intérprete Python. Não será capaz de executar o seu código sem ele. Felizmente, o 
Python é gratuito. Esta é uma das suas vantagens mais importantes. 
Devido a razões históricas, as linguagens concebidas para serem utilizadas na forma de interpretação são muitas vezes chamadas 
linguagens de scripting, enquanto os source programs codificados que as utilizam são chamados scripts8. 
“PHYTON É UMA FERRAMENTA E NÃO UM RÉPTIL” 
1.9 O que é o Python? 
O Python é uma linguagem de programação de grande utilização, interpretada, orientada a objetos, e de alto nível com semântica 
dinâmica, utilizada para programação de uso geral. 
E embora possa conhecer o Python (píton ou píton)como uma grande serpente, que na mitologia Píton é uma serpente de cem 
cabeças, morta a flechadas pelo Deus Apolo, o nome da linguagem de programação Python vem de uma antiga série de comédia televisiva 
da BBC chamada Monty Python's Flying Circus. No auge do seu sucesso, a equipa Monty Python estava a realizar os seus sketches 
para audiências ao vivo em todo o mundo, incluindo no Hollywood Bowl. Uma vez que os Monty Python são considerados um dos dois 
 
8 Script – É um conjunto de instruções escritas em uma linguagem de programação que é executado por um interpretador. 
Características: Um Script geralmente são interpretados ao invés de serem compilados. São frequentemente usados par 
automatizar tarefas repetidas, como processamento de dados, configuração de sistemas e gerenciamento de arquivos; 
Possuem grande portabilidade, a maioria dos scripts podem ser executados em diferentes sistemas operacionais, desde 
que o interpretador adequado esteja disponível; E um fator muito importante é a simplicidade, as sintaxes dos scripts de 
muitas lingagesn são projetadas para serem simples, de fácil entendimento, o que o torna muito acessível a iniciantes. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[15] 
nutrientes fundamentais para um programador (sendo o outro pizza), o criador de Python nomeou a linguagem em honra do programa 
de televisão. 
Quem criou o Python? 
Uma das características espantosas de Python é o facto de ser realmente 
o trabalho de uma pessoa. Normalmente, novas linguagens de programação são 
desenvolvidas e publicadas por grandes empresas que empregam muitos 
profissionais, e devido às regras de direitos autorais, é muito difícil nomear 
qualquer uma das pessoas envolvidas no projeto. O Python é uma exceção. 
Não há muitas linguagens cujos autores sejam conhecidos pelo nome. O 
Python foi criado por Guido van Rossum, nascido em 1956 em Haarlem, 
Holanda. É claro que Guido van Rossum não desenvolveu e evoluiu ele próprio 
todos os componentes de Python. 
A rapidez com que o Python se espalhou pelo mundo é o resultado do 
trabalho contínuo de milhares (muitas vezes anónimos) de programadores, 
testadores, utilizadores (muitos deles não são especialistas em TI-Tecnologia da Informação) e entusiastas, mas deve dizer-se que a 
primeira ideia (a semente da qual o Python brotou) chegou a uma cabeça. 
Um dos motivos de se escolher à linguagem Phyton, além da gratuidade, é a facilidade em instalar os softwares necessários para 
programar nesta linguagem (sim, para criar programas é preciso utilizar outros programas) e da forma mais simplificada para a 
escrita do código. 
Ao mesmo tempo, isso não quer dizer que ela seja uma linguagem limitada ou de iniciantes apenas. O Python é utilizado por grandes 
empresas de tecnologia como Google, Instagram e Facebook e atualmente é uma das principais linguagens de programação do mercado 
com inúmeras ofertas de trabalho (REALPYTHON, 2020). Essa linguagem possibilita a criação de aplicativos para computador, Internet, 
dispositivos móveis (smartphones), jogos, entre outros. O que faz da linguagem Phyton uma grande utilidade no seu futuro profissional. 
O que torna o Python especial? 
Como é que os programadores, jovens e velhos, experientes e novatos, querem 
utilizá-lo? Como aconteceu que grandes empresas adotassem o Python e 
implementassem os seus principais produtos utilizando-o? 
Há muitas razões - já enumerámos algumas delas, mas vamos enumerá-las 
novamente de uma forma mais prática: 
• é fácil de aprender - o tempo necessário para aprender Python é menor do 
que para muitas outras linguagens; isto significa que é possível iniciar a 
programação em si mais rapidamente; 
• é fácil de ensinar - a carga de trabalho de ensino é menor do que a necessária para outras linguagens; isto significa que 
o professor pode colocar mais ênfase em técnicas de programação gerais (independentes da linguagem), não 
desperdiçando energia em truques exóticos, estranhas exceções e regras incompreensíveis; 
• é fácil de usar para escrever novo software - é muitas vezes possível escrever código mais rapidamente quando se usa 
Python; 
• é fácil de compreender - é também frequentemente mais fácil e rápido de compreender o código de outra pessoa se for 
escrito em Python; 
• é fácil de obter, instalar e implementar - o Python é gratuito, aberto e multiplataforma; nem todas as linguagens se podem 
gabar disso. 
É claro que o Python também tem os seus inconvenientes: 
• não é um demónio da velocidade - o Python não oferece um desempenho excecional; 
• em alguns casos pode ser resistente a algumas técnicas de teste mais simples - isto pode significar que depurar o código 
Python pode ser mais difícil do que com outras linguagens; felizmente, cometer erros é sempre mais difícil em Python. 
https://en.wikipedia.org/wiki/Guido_van_Rossum
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[16] 
Um projeto de programação de hobby 
As circunstâncias em que o Python foi criado são um pouco confusas. De acordo com Guido van Rossum: 
“Em dezembro de 1989, estava à procura de um projeto de 
programação de "hobby" que me mantivesse ocupado durante a 
semana por volta do Natal. O meu escritório (...) estaria fechado, 
mas eu tinha um computador em casa, e não tinha muito mais nas 
mãos. Decidi escrever um intérprete para a nova linguagem de 
escrita em que tinha pensado ultimamente: um descendente do 
ABC que apelaria aos hackers Unix/C. Escolhi Python como título 
de trabalho para o projeto, estando de humor ligeiramente 
irreverente (e sendo um grande fã do Monty Python's Flying 
Circus).” 
Objetivos do Python 
Em 1999, Guido van Rossum definiu os seus objetivos para o 
Python: 
• uma linguagem fácil e intuitiva, tão poderosa como a dos principais concorrentes; 
• de open source, para que qualquer pessoa possa contribuir para o seu desenvolvimento; 
• código que seja tão compreensível como o inglês simples; 
• adequado para tarefas quotidianas, permitindo tempos de desenvolvimento curtos. 
Cerca de 20 anos mais tarde, é evidente que todas estas intenções foram cumpridas. Algumas fontes dizem que o Python é a 
linguagem de programação mais popular no mundo, enquanto outras afirmam que é a terceira ou a quinta. Seja como for, continua a 
ocupar uma posição elevada no top dez do PYPL Popularity of Programming Language e no TIOBE Programming Community Index. 
O Python não é uma linguagem jovem. É madura e confiável. Não é uma one-hit wonder. É uma estrela brilhante no firmamento da 
programação, e o tempo gasto a aprender Python é um investimento muito bom. O processo de criação de aplicativos envolve, 
basicamente, a escrita dos nossos algoritmos e uma forma de executá-los. Podemos utilizar qualquer editor de textos para escrever 
códigos Python, como o bloco de notas do Windows. No entanto, em geral utilizamos editores especializados, como o Microsoft Visual 
Studio Code (https://code.visualstudio.com/), que é gratuito, e oferecem recursos para apoiar a criação de programas. 
Além de um editor, precisamos de um programa que será utilizado para a execução do nosso código de programação. O intérprete, 
que entende a linguagem de programação e a traduz para a linguagem de máquina, o formato realmente compreendido pelo computador. 
No Python o interpretador precisa ser instalado. Ele também tem como objetivo verificar se o nosso código segue a sintaxe 
corretamente, apresentando um aviso em caso de problema. 
O interpretador está disponível para múltiplos sistemas operacionais (Windows, macOS, Linux, entre outros) e pode ser 
descarregado pelo site oficial no endereço https://www.python.org/downloads/. Ao acessar esse link você encontrará várias versões 
do Python, recomenda-se sempre a mais nova, na última versão que instale a versão 3+, pois a versão 2+ existe para fins de suporte 
legado e deixou de receber atualizações. Além disso, como este livro foi escrito direcionado ao Python 3+, pode ser alguns dos recursosnão funcionem no Python 2+. 
 
FIG. 06 -IMAGEM DA INTERFACE DO PHYTON IDLE SHELL NA VERSÃO 3.12.5 
https://code.visualstudio.com/
https://www.python.org/downloads/
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[17] 
Há diversas opções para a instalação no Windows e recomendamos o uso do Windows Installer, que pode ser 32 ou 64bits a 
depender do seu sistema operacional. Após a finalização deste processo o instalador criará uma entrada no Menu Iniciar onde é possível 
acessar o Python Idle Shell. Esse programa possibilita a escrita de códigos de programação diretamente nele, como também a execução 
de códigos escritos em outros editores. Para este último caso, você deve acessar o menu File e em seguida clicar em Open. Após isso, 
escolha o arquivo que contém os códigos de programação (extensão .py) e ele será executado. 
A instalação no macOS também é feita por um instalador próprio (extensão .pkg) localizado no mesmo site. Para o Linux deve-se 
consultar os repositórios oficiais da distribuição onde o Python será instalado. Em ambos os sistemas operacionais (macOS e Linux) há 
uma grande chance de você já possuir uma versão do Python instalada por padrão. 
A instalação no macOS também é feita por um instalador próprio (extensão .pkg) localizado no mesmo site. Para o Linux deve-se 
consultar os repositórios oficiais da distribuição onde o Python será instalado. Em ambos os sistemas operacionais (macOS e Linux) há 
uma grande chance de você já possuir uma versão do Python instalada por padrão. 
1.10 INSTALAÇÃO DO PHYTON 
Podemos usar o python online (https://edube.org/sandbox) 
ENTRAR NO SITE: https://www.python.org/downloads/ 
 
FIG. 07 -IMAGEM DA PÁGINA PARA BAIXAR O PHYTON 
 
PRIMEIRO ESCOLHA O SISTEMA QUE VAI INSTALAR E BAIXE O APLICATIVO 
EM WINDOWS 
Executar o arquivo baixado como administrador; (Phython, versão 3.12.5(64bits)) 
Abrirá a tela de Instalação Fig. 08, onde deve ser clicado em Install Now 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[18] 
 
FIG. 08 -IMAGEM INSTALAÇÃO DO PHYTON PARA WINDOWS 
 
Aguardar a Instalação, a tela de instalação irá mudar, e aparecerá a Barra de Progresso da Instalação como Fig. 09 
 
FIG. 09 -IMAGEM INSTALAÇÃO BARRA DE PROGRESSO DA INSTALAÇÃO PHYTON PARA WINDOWS 
 
A barra de progresso mostra a evolução da instalação, conforme mostrado na Fig. 10, aguarde a fiscalização 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[19] 
 
FIG. 10 -IMAGEM INSTALAÇÃO DO PHYTON BARRA DE PROGRESSO 
 
 Ao concluir o programa informará que A instalação foi concluída com sucesso, conforme a Fig. 11, clicar em Close (fechar) 
 
FIG. 11 -IMAGEM DA CONCLUSÃO COM SUCESSO DO SETUP PHYTON 
 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[20] 
EM LINUX 
Os sistemas GNU/Linux mais recentes já possuem uma versão do Python instalada junto com o sistema operacional. Podemos 
checar com o seguinte comando: 
 
que nos mostra onde o Python padrão do sistema operacional está instalado. 
A versão do Python na distribuição Linux Ubuntu 22.04.2 LTS é a 3.10. 
 
Para evitar conflitos com o Python do sistema operacional, sugere-se a instalação de um outro interpretador, que pode ser feita 
de 2 formas diferentes: através do de gerenciador de pacotes ou de repositórios. 
Instalação por gerenciamento de pacotes: . apt-get . (Debian,Ubuntu) e . yum . (RedHat,CentOS) 
Debian e Ubuntu 
. $ sudo apt-get install python3.9 . 
É possível instalar outras versões: 3.10; 3.11 e 3.12. 
RedHat e CentOS 
. $ sudo yum install python3.9 . 
Instalação por repositório 
Os repositórios no GNU/Linux são chamados de PPAs (do inglês Personal Package Archives). 
Para adicionar repositórios ao nosso sistema, precisamos de um software chamado . software-properties-common ., que pode ser 
instalado com o comando abaixo: 
. $ sudo apt-get install software-properties-common . 
Habilitada a adição de repositórios ao nosso sistema operacional, podemos agora incluir o repositório que contém o Python. Este 
repositório é chamado de deadsnakes, cuja página oficial é: https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa. 
. $ sudo apt-get-repository ppa:deadsnakes/ppa . 
Desta forma a instalação já pode ser feita via repositório 
. $ sudo apt-get install python3.9 . . 
EM Mac OS X 
Verifica se o Phyton já estar instalado, caso seja um MacOS 10.2 ou superior, provavelmente já possui, para conferir via terminal: 
. $ wich python . 
ou 
. $ wich python3 . 
O comando deve retornar algo como . /usr/bin/python . . isso significa que o Phyton está instalado nesse endereço. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[21] 
Instalação do zero 
Antes de fazer a instalação do Python, é preciso fazer a instalação do XCode, que pode ser baixado na App Store, do pacote para 
desenvolvimento em linha de comando no macOS, command line tools e dos gerenciadores de pacotes pip e homebrew. 
Entrar no terminal e digitar: 
. $ xcode-select –install . 
Para instalar o pop, digite em um terminal: 
. $ sudo eady_install pip . 
Para atualizar o pip, no terminal digite: 
. $ sudo pip install - -upgrade pip . 
Para instalar o homebrew, digitar em terminal: 
. $ Ruby -e “$(curl -fsSL https://raw.github.com/mxcl/homebrew/go)” ” 
Para instalar o Phyton 3 
. $ brew install python3 . 
1.11 Como escrever e executar o seu primeiro programa 
O primeiro passo é criar um novo source file e preenchê-lo com código. Clique em File no menu do IDLE e escolha New file. 
 
FIG. 12 -IDLE SHELL PHYTON CRIAÇÃO DE UM NOVO ARQUIVO, E O EDITOR DE CÓDIGO 
 
Esta é a janela do editor tem como único objetivo é ser um local de trabalho em que o seu source code é tratado. Não confundir a 
janela do editor com a janela shell. Desempenham funções diferentes. 
A janela do editor está atualmente sem título, mas é uma boa prática começar a trabalhar nomeando o source file. 
Clique em File (na nova janela), depois clique em Save as..., selecione uma pasta para o novo arquivo (o ambiente de trabalho é um 
bom local para as suas primeiras tentativas de programação) e escolha um nome para o novo arquivo. 
https://raw.github.com/mxcl/homebrew/go
Introdução à Programação Estruturada 
Prof.: André Andrade[22] 
 
FIG. 13 - EDITOR DE CÓDIGO COM O LOCAL DE GRAVAÇÃO DO PROGRAM PROGRAMAX.PY 
Nota: não defina nenhuma extensão para o nome do arquivo que vai utilizar. O Python precisa que os seus arquivos tenham a 
extensão .py, por isso deve confiar nas predefinições da janela de diálogo. A utilização da extensão padrão .py permite que o sistema 
operativo abra adequadamente estes arquivos. 
Escrevendo um programa: 
Agora coloque apenas uma linha na sua janela do editor recém-aberta e nomeada. 
A linha tem este aspeto: 
 
FIG. 14 - EDITOR DE CÓDIGO COM A SINTAXE DA FUNÇÃO PRINT 
Se tudo correr bem e não houver erros no código, a janela da consola irá mostrar-lhe os efeitos causados pela execução do 
programa. 
Neste caso, o programa sibila9. Tente executá-lo mais uma vez. E mais uma vez. 
Agora feche ambas as janelas e regresse ao ambiente de trabalho. 
 
FIG. 15 – O IDLE SHELL COM A EXECUÇÃO REITERADA DO PROGRAMAX.PY 
 
9 Sibilar - Assobiar como as cobras. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[23] 
Como estragar e corrigir o seu código 
Agora reinicie o IDLE. 
• Clique em File, Open, aponte para o arquivo que guardou anteriormente e deixe o IDLE lê-lo. 
• Tente executá-lo novamente pressionando F5 quando a janela do editor estiver ativa. 
Como pode ver, o IDLE é capaz de guardar o seu código e recuperá-lo quando precisar dele novamente. 
O IDLE contém um recurso adicional e útil. 
• Primeiro, remova o parêntesis final. Salve e tente executar o programa: 
o Receberá uma tela de Erro de Sintaxe: 
 
FIG. 16 – TELA DE ERRO DE SINTAXE 
 O CÓDIGO FICA COM O ERRO EVIDENCIADO, O QUE AJUDO O PROGRAMADOR ENXERGAR E CORRIGIR OS ERROS 
 
FIG. 17 – TELA DO EDITOR DO PROGRAMA, COM O ERRO EVIDENCIADO 
• Em seguida, insira o parêntesis novamente. 
Cada vez que colocar o parêntesis final no seu programa, o IDLE mostrará a parte do texto limitada com um par de parêntesis 
correspondentes. Isto ajuda-o a lembrar-se de os colocar em pares. 
Retire novamente o parêntesis final. O código torna-se incorreto. Contém agora um erro de sintaxe. O IDLE não deve deixar que o 
execute. 
Tente executar o programa novamente. O IDLE irá lembrá-lo de guardar o arquivo modificado. Siga as instruções. (Em versões mais 
antigas podem aparecer outros erros, ao invés de erro de sintaxe, na versão 3.7.0 o erro que apresenta é: EOF (end-of-file).) 
Corrija o código e veja se “sibila” novamente. 
Agora vamos novamente estragar o programa, removendo uma letra da palavra print, salve o programa e execute-o novamente. 
Devemos notar que a mensagem de erro gerada para o erro anterior é bastante diferente da primeira. Isto acontece porque a 
natureza do erro é diferente e o erro é descoberto numa fase diferente de interpretação. A Fig. 18, temos a tela com o erro gerado. 
A janela do editor não fornecerá qualquer informação útil sobre o erro, mas as janelas da consola poderão. 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[24] 
 
FIG. 17 – TELA DO EDITOR DO PROGRAMA, COM O ERRO EVIDENCIADO 
Apresentar a mensagem (em vermelho) mostradas (nas linhas subsequentes): 
• o traceback (que é o caminho que o código percorre através de diferentes partes do programa - pode ignorá-lo por agora, 
uma vez que está vazio num código tão simples); 
• a localização do erro (o nome do arquivo contendo o erro, o número da linha e o nome do módulo); nota: o número pode 
ser enganador, uma vez que o Python normalmente mostra o local onde primeiro se notam os efeitos do erro, não 
necessariamente o erro em si; 
• o conteúdo da linha errada; nota: a janela do editor IDLE não mostra os números das linhas, mas mostra a localização 
atual do cursor no canto inferior direito; use-a para localizar a linha errada num source code longo; 
• o nome do erro e uma breve explicação. 
Experimente criar novos arquivos e executar o seu código. Tente fazer output de uma mensagem diferente na tela, por exemplo 
rugir! miar, ou até mesmo talvez um oink!. Tente estragar e corrigir o seu código - veja o que acontece. 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[25] 
1.12 Questões 
1. O que são aplicativos? 
2. Cite dois exemplos de dispositivos de entrada e saída para o computador. 
3. O que é a sintaxe de uma linguagem de programação? 
4. O que são algoritmos de computação e quais as regras existentes para a sua criação? 
5. Para que utilizamos as instruções em programação? 
6. Por que a programação é uma importante área para a nossa sociedade atual? 
7. Por que precisamos da linguagem de programação? 
8. Phyton é um exemplo de: 
( ) uma linguagem de máquina 
( ) uma linguagem natural 
( ) uma linguagem de programação de alto nível 
9. Um conjunto completo de comandos conhecidos é chamado de: 
( ) uma lista de máquinas 
( ) Uma lista de instruções 
( ) uma lista de baixo nível 
 
10. O que é um source code? 
( ) outro nome para source file 
( ) código de máquina executado por computadores 
( ) um programa escrito numa linguagem de programação de alto nível 
 
11. Como se chama um programa de computador que executa diferentemente instruções escritas numa linguagem de programação? 
( ) um intérprete 
( ) um compilador 
( ) um tradutor 
 
12. Qual a versão de Phyton abordaremos? 
( ) Phyton 5 
( ) Phyton 2 
( ) Phyton 3 
 
13. O que é CPython? 
( ) É outro nome para o Cython, um superconjunto da linguagem de programação Phyton 
( ) É uma linguagem compilada usada para executar funções de programação de alto nível 
( ) A implementação padrão da linguagem de programação Python 
 
14. O que é IDLE do Python? 
( ) É uma versão de Python 
( ) É um acrónimo para Integrated Development and Learning Environment para Python 
( ) é um acrónimo que signigica Interactive Development and Lerarning Extension 
( ) É quando o computador entra em marcha lenta 
 
Introdução à Programação Estruturada 
Prof.: André Andrade 
 
[26] 
15. Como se chama uma ferramenta que lhe permite lançar o seu código passo a passo e interpretá-lo em cada momento da exrcução? 
( ) um editor 
( ) um debugger 
( ) uma console 
 
16. Como é que o Python, a linguagem de programação, recebeu o seu nome? 
( ) Guido Van Rossum deu-lhe o nome de Pythonidae – uma família de cobras grandes e não venenosas 
( ) Guido Van Rossum nomeou-o para homenagear Monty Python´s Flying Circus, uma série de comédia da BBC popular na 
década de 1970 
( ) Guido Van Rossum nomeou-o em hora de Python of Catana, um poeta dramático da época de Alexandre o Grande 
 
17. Qual dos seguintes é um exemplo de extensão de um arquivo Python? 
( ) py 
( ) pi 
( ) p 
 
18. O que é código de máquina? 
( ) uma linguagem de programação de baixo nível, constituída por dígitos/bits binários que o computador lê e compreende. 
( ) uma linguagem de programação de nível intermediário, que consiste no código de montagem desenhado para o processador 
do computador 
( ) uma linguagem de programação de baixo nível, que consiste em dígitos hexadecimais que compões instruções de linguagem 
de alto nível 
( ) Uma linguagem de programação de alto nível, que consiste em listas de instruções que os seres humanos podem ler e 
compreender 
 
19. Como se chama um intérprete de linha de comando que lhe permite interagir com o seu sistema operativo, e executar comandos 
e scripts de Python? 
( ) Um console 
( ) Um editor 
( ) Jython 
( ) Um compilador 
 
20. Qual é o componente esperado do seguinte programa? 
Prin(“Goodbye!”) 
 
( ) o programa irá gerar uma mensagem de erro 
( ) o programa fará output Goodbye! para a tela 
( ) o programa fará output “Goodbye!” 
( ) o programa fará output (“Goodbye!”) 
 
21. Como se chama um arquivo que contém um programa escrito numa linguagem de programação de alto nível? 
( ) Um arquivo de máquina 
( ) Um arquivo de destino 
( ) Um arquivo de origem 
( ) Um arquivo de código 
 
Introdução à Programação Estruturada