ufpi cshnb

Introdução à Computação
Algoritmo e Introdução ao Python
Profª. Dra. Eunice Bezerra

1 / 113
Algoritmo
 ufpi cshnb

Algoritmo

• Um algoritmo é a descrição de um padrão de comportamento,

expressado em termos de um repertório bem definido e finito
de ações “primitivas”, das quais damos por certo que elas
podem ser executadas;
• Um algoritmo pode ser definido como uma sequência finita de
passos (instruções) para resolver um determinado problema;
• Um algoritmo é desenvolvido estabelecendo um padrão de
comportamento que deverá ser seguido (uma norma de
execução de ações) para alcançar o resultado de um problema;

3 / 113
 ufpi cshnb

Algoritmo

Premissas básicas na construção de um algoritmo:

• Definir ações simples e sem ambiguidade;
• Organizar as ações de forma ordenada;
• Estabelecer as ações dentro de uma sequência finita de passos;

4 / 113
ufpi cshnb

5 / 113
 ufpi cshnb

Algoritmo

Os algoritmos são capazes de realizar tarefas como:

1 Ler e escrever dados;
2 Avaliar expressões algébricas, relacionais e lógicas;
3 Tomar decisões com base nos resultados das expressões
avaliadas;
4 Repetir um conjunto de ações de acordo com uma condição;

6 / 113
ufpi cshnb

7 / 113
 ufpi cshnb

Algoritmo

Um algortimo quando programado num computador contém

no mínimo três partes:
1 Entrada de dados;
2 Processamento de dados;
3 Saída de dados;

8 / 113
 ufpi cshnb

Algoritmo

Entrada de dados
• A execução de um algoritmo requer o fornecimento das
informações necessárias para realizar os comandos (as
instruções a serem seguidas);
• Essas informações também podem ser referidas como valores
iniciais;

Processamento de dados
• É nessa parte em que todas as expressões algébricas,
relacionais e lógicas são avaliadas;
• Além de todas as estruturas de controle existentes no
algoritmo (condição e/ou repetição);

9 / 113
 ufpi cshnb

Algoritmo

Saída de dados
• Todos os resultados do processamento (ou parte deles) são
enviados para um ou mais dispositivos de saída, como:
monitor, impressora, ou até mesmo a própria memória do
computador;

10 / 113
 ufpi cshnb

Pseudocódigo

• Trata-se de uma maneira intermediária entre a linguagem

natural e uma linguagem de programação de representar um
algoritmo;
• Utiliza-se um conjunto restrito de palavras-chave, em geral na
língua nativa do programador, que tem equivalentes nas
linguagens de programação;

11 / 113
ufpi cshnb

12 / 113
Representação de Dados
 ufpi cshnb

Tipos Primitivos de Dados

• Inteiro: São os números pertencentes ao conjunto dos

Inteiros, isto é, que não possuem parte fracionária;
• Real: São os números pertencentes ao conjunto dos Reais,
isto é, que podem possuir parte fracionária;
• Caractere: São os valores pertencentes ao conjunto de todos
os caracteres numéricos (0...9), alfabéticos (a...z,A...Z) e
especiais (#, $, %, & entre outros);
• Esse conjunto também é conhecido como conjunto de
caracteres alfanuméricos;
• Lógico: O tipo lógico é utilizado para representar informações
que só podem assumir dois valores, o valor verdadeiro (V) ou
o valor falso (F);

14 / 113
 ufpi cshnb

Constantes e Variáveis

• Um dado é considerado constante quando seu valor não se

altera ao longo do tempo em que o algoritmo é executado, ou
seja, permanece o mesmo desde o início até o final da
execução;
• Um dado é considerado como sendo uma variável quando um
dado que pode ter seu valor alterado durante a execução do
programa;
• Por exemplo, no cálculo da área de uma circunferência
(A = πr 2 ), o valor de π é constante, pois é sempre igual a
3,1416..., e o raio r é variável;

15 / 113
 ufpi cshnb

Manipulação de Dados

Identificação
• Para que os dados sejam manipulados no computador, é
necessário que estes estejam associados a um nome, um
identificador;
• O conteúdo deste identificador será o dado em si e o seu nome
será usado para acessar o dado e realizar operações com o
mesmo;
• Ao nomearmos os identificadores dos nossos dados é
conveniente usarmos palavras mnemônicas, ou seja, palavras
que nos façam lembrar o caráter do conteúdo armazenado;
• Isso facilita a leitura do código programado e possibilita uma
melhor documentação do mesmo.

16 / 113
 ufpi cshnb

Manipulação de Dados

regras para a nomeação dos identificadores:

1 Sempre começar com um caractere alfabético;
2 Pode ser seguido por um ou mais caracteres alfanuméricos;
3 Não conter caracteres especiais nem espaços com exceção do
sublinhado _;
4 Não é permitido utilizar palavras reservadas (palavras próprias
da linguagem de programação, como os comandos, tipos de
variáveis, etc);

17 / 113
 ufpi cshnb

Manipulação de Dados

Identificação
• Exemplos de identificadores válidos: raio, _nome, R,
num_clientes, BJ33f15, NumPessoasDoentes;
• Exemplos de identificadores inválidos: (ee), 32-vr, mil*,
12ddd, o:P;

18 / 113
 ufpi cshnb

Manipulação de Dados

Definição
• O primeiro passo para utilizarmos os dados é a nomeação do
seu idenficador e a definição do seu tipo (no caso de
identificadores variáveis), ou do seu valor (no caso de
identificadores constantes);
• A definição dos dados em algoritmos também é conhecida
como declaração;
• Um identificador declarado com um determinado tipo de dados
ficará restrito a armazenar valores daquele tipo específico;
var
nome: caractere;

19 / 113
 ufpi cshnb

Manipulação de Dados

Atribuição
• Após realizada a declaração de um identificador, é possível
iniciar a manipulação dos dados que esse identificador irá
representar a partir da atribuição de valores ao mesmo;
• A atribuição de valores a uma variável é feita da seguinte
forma:
<idenfiticador da variável> recebe <valor do mesmo tipo da
variável>;
<idenfiticador da variável> recebe <operações cujo resultado é do
mesmo tipo da variável>;

20 / 113
ufpi cshnb

21 / 113
Introdução à Computação
com Python
 ufpi cshnb

Introdução à Computação com

Python

• Aprender a lógica do pensamento computacional;

• Explorar a arte de solução de problemas via computação;
• Fazer com que o computador faça o que você quer;

23 / 113
 ufpi cshnb

O que Computador faz?

Fundamentalmente:
• realiza cálculos;
• lembra resultados;

24 / 113
 ufpi cshnb

Existe limite para o que um

Computador é capaz de fazer?

Alguns problemas ainda são muito complexos:

• predizer o clima em escala local;
• quebrar esquemas de criptografia;

Alguns problemas são fundamentalmente impossíveis de

calcular:
• predizer se um pedaço de código sempre irá fornecer uma
resposta para qualquer que seja o dado de entrada;

25 / 113
 ufpi cshnb

Tipos de Conhecimento

• O computador sabe o que você diz a ele;

• Conhecimento declarativo: afirmações de um fato;
• Conhecimento imperativo: como fazer algo, uma receita;

26 / 113
 ufpi cshnb

O que é uma receita?

1 Sequência de passos simples;

2 Fluxo de controle de processo que especifica quando cada
passo será executado;
3 Meios de determinar quando o processo termina;
Esses passos constituem um algoritmo!

27 / 113
 ufpi cshnb

O computador é uma máquina

• Como capturar a essência de uma receita em um processo

mecânico?
• Computadores de programa fixo (por exemplo, a calculadora);
• Computadores de programa armazenado: a máquina armazena
e executa instruções;

28 / 113
 ufpi cshnb

Computadores de programa
armazenado

Sequência de instruções armazenadas dentro do computador:

• construído a partir de um conjunto de instruções primitivas:
1 Aritmética e lógica;
2 Testes simples;
• Um programa espacial chamado de interpretador executa os
programas em ordem:
• usa testes para mudar o fluxo de controle através da sequência;
• para quando o processo estiver concluído.

29 / 113
 ufpi cshnb

IMPORTANTE

Qualquer coisa computável em uma linguagem de programação é

computável em qualquer outra linguagem de programação.

30 / 113
Linguagens de Programação
 ufpi cshnb

Linguagens de Programação

Criando Receitas
• Uma linguagem de programação fornece um conjunto de
operações primitivas;
• Em uma linguagem de programação, existem expressões que
são combinações legais de operações;
• Expressões e cálculos têm valores e significados em uma
linguagem de programação;

32 / 113
 ufpi cshnb

Aspectos de uma Linguagem

Construções primitivas
• Português: palavras;
• Linguagem de programação: números, caracteres e operadores
simples;

33 / 113
 ufpi cshnb

Aspectos de uma Linguagem

Sintaxe
• Português:
• "cachorro gato vaca"→ não é sintaticamente válido;
• "O cachorro bebe água"→ sintaticamente válido;
• Linguagem de programação:
• "Oi"7 → não é sintaticamente válido;
• 3.2+1 → sintaticamente válido;

34 / 113
 ufpi cshnb

Aspectos de uma Linguagem

Semântica (erros de construção)

• Português:
• "Eu vamos ao cinema"→ sintaticamente válido mas tem erro
de semântica;
• Linguagem de programação:
• 3.2+1 → sintaticamente válido;
• 3.2+"Oi"→ erro semântico;

35 / 113
 ufpi cshnb

Aspectos de uma Linguagem

Semântica (diferentes significados)

• Português: gramática correta, mas múltiplos sentidos;
• Linguagem de programação: tem somente um significado, mas
pode não ser aquele originalmente pretendido pelo
programador;

36 / 113
 ufpi cshnb

Tipos de Erro

• Erros de sintaxe;
• Erros de semântica (construção das expressões);
• Construção de semântica válida com significado diferente do
originalmente pretendido:
• O programa pode parar de funcionar;
• O programa pode rodar para sempre;
• O programa fornece um resultado diferente do pretendido.

37 / 113
Programas em Python
 ufpi cshnb

Programas em Python

• Um programa é uma sequência de definições e comandos;

• Os comandos dizem ao interpretador Python o que fazer;
• Os comandos podem ser digitados diretamente no Shell ou no
Editor;

39 / 113
 ufpi cshnb

Objetos

• Programas manipulam data objects;

• Objetos tem tipos específicos;
• Objetos podem ser classificados como:
• Escalares: não podem ser dividos;
• Não-escalares: apresentam estrutura interna que pode ser
acessada;

40 / 113
 ufpi cshnb

Objetos Escalares

• int - representa números inteiros (ex: 3);

• float - representa números reais (ex: 3.0);
• bool - representa os valores lógicos True e False;
• NoneType - é um tipo especial que só possui o valor None;
• Você pode utilizar o comando type() para saber o tipo de
uma objeto;

41 / 113
 ufpi cshnb

Tipos de Conversão

• É possível converter um objeto de um tipo para outro:

• float(3) converte o número inteiro 3 no número real 3.0;
• int(3.9) realiza o truncamento do número real 3.9 para o
npumero inteiro 3;

42 / 113
 ufpi cshnb

Expressões

• Expressões são formadas pela combinação de objetos e

operadores;
• Uma expressão tem um valor;
• Um valor tem um tipo;
• Sintaxe para uma expressão simples:
<objeto> <operador> <objeto>;

43 / 113
 ufpi cshnb

Operadores para Inteiros e Reais

• i + j → soma;
• i − j → diferença;
• i ∗ j → produto;
• i/j → divisão (o resultado é real);
• i//j → divisão inteira (o resultado é inteiro e corresponde ao
quociente);
• i % j → fornece o resto da divisão de i por j;
• i ∗ ∗j → i elevado a potência j;

44 / 113
 ufpi cshnb

Exemplo: i = 7 e j = 3

• 7 + 3 resulta em 10;
• 7 − 3 resulta em 4;
• 7 ∗ 3 resulta em 21;
• 7/3 resulta em 2,33;
• 7//3 resulta em 2;
• 7 % 3 resulta em 1;
• 7 ∗ ∗3 resulta em 343;

45 / 113
 ufpi cshnb

Operações Simples

• Os parênteses podem ser utilizados para a ordem das

operações:
• 3 ∗ 3 + 1 resulta em 10;
• 3 ∗ (3 + 1) resulta em 12;
• Na ausência de parênteses temos a seguinte ordem de
precedência entre os operadores:
1 ∗∗
2 ∗
3 /
4 + ou - (executado da direita para a esqueda)

46 / 113
 ufpi cshnb

Ligando Variáveis e Valores

• Atribui-se um valor a uma variável através do sinal ’=’;

• Exemplo: pi = 3,14;
• O valor é guardado na memória do computador;
• O nome é ligado a esse valor por meio desse processo de
atribuição;
• O valor pode ser obtido invocando o nome a ele associado;
• No caso acima, digitando pi;

47 / 113
 ufpi cshnb

Abstraindo Expressões

• Por que dar nome a valores?

• Reutilizar nomes ao invés de valores;
• A alteração do código fica mais fácil;

pi = 3,14
raio = 2
area = pi*(raio**2)

48 / 113
 ufpi cshnb

Programação vs Matemática

Em programação, você não ’resolve para x’

pi = 3,14
raio = 2
# Área do círculo
area = pi*(raio**2)
raio = raio + 1

49 / 113
 ufpi cshnb

Incremento
’raio = raio + 1’ é equivalente ao comando ’raio += 1’

Decremento
’raio = raio - 1’ é equivalente ao comando ’raio -= 1’

50 / 113
 ufpi cshnb

Escrita de Operações Aritméticas

• Cada operação aritmética em um algoritmo deve ser escrita

em apenas uma única linha;
• Sendo assim, quando uma expressão matemática usual é
escrita precisamos utilizar parênteses para garantir que todas
as operações sejam executadas na ordem adequada;
• Por exemplo, o código para a expressão
√
3+ 9+4
+ 67
8
seria
((3 + (9 + 4)**(1/2))/(8)) + 67

51 / 113
 ufpi cshnb

Alterando a Ligação entre Variável e

Valor

• É possível mudar o valor a que a variável se refere fazendo

uma nova atribuição;
• O valor anterior ainda continua na memória, mas você não é
mais capaz de acessá-lo;
• O valor da área não muda até que você diga ao computador
para realizar o cálculo novamente;

52 / 113
 ufpi cshnb

Expressões Lógicas
Operadores Relacionais ou de Comparação
• São aqueles que comparam dois valores do mesmo tipo;
• O retorno da expressão relacional indica se o resultado da
comparação foi verdadeiro ou falso;
• Por exemplo, a expressão 2 < 3 é verdadeira;

Operadores Lógicos
• São usados para representar situações lógicas que não podem
ser representadas por operadores aritméticos;
• Também são chamados conectivos lógicos por unirem duas
expressões simples numa composta;
• Os operadores lógicos estabelecem relações de “e”, “ou” e
“não é”;

53 / 113
 ufpi cshnb

Operadores de Comparação
int e float
• i > j → retorna True se i é maior que j, ou False caso
contrário;
• i >= j → retorna True se i é maior ou igual a j, ou False
caso contrário;
• i < j → retorna True se i é menor que j, ou False caso
contrário;
• i <= j → retorna True se i é menor ou igual a j, ou False
caso contrário;
• i == j → teste de igualdade, retorna True se i é igual a j, ou
False caso contrário;
• i ! = j → teste de diferença, retorna True se i é diferente de j,
ou False caso contrário;

54 / 113
 ufpi cshnb

Exemplo: i = 7 e j = 3

• 7 > 3 resulta em True;

• 7 >= 3 resulta em True;
• 7 < 3 resulta em False;
• 7 <= 3 resulta em False;
• 7 == 3 resulta em False;
• 7! = 3 resulta em True;

55 / 113
 ufpi cshnb

Operadores Lógicos

• Os operadores lógicos são usados para representar situações

lógicas que não podem ser representadas por operadores
aritméticos;
• Podem ser operadores binários, que operam em duas sentenças
ou expressões, ou unário que opera numa sentença só;
• Permitem a combinação de testes lógicos;
• Temos três tipo de testes:
• and
• or
• not

56 / 113
 ufpi cshnb

and

• O operador binário de conjunção ou e lógico é representado

pelo termo em inglês and;
• Quando duas expressões são unidas por este operador, a
expressão resultante só é verdadeira se ambas expressões
constituintes também são;
• O resultado da operação é do tipo lógico: verdadeiro (True)
ou Falso (False);

57 / 113
 ufpi cshnb

and

• Teste1 and Teste2 → retorna True se AMBOS Teste1 e

Teste2 forem verdadeiros, caso contrário, False;
• Exemplo: 3 < 7 and 8 > 6 → ambos os testes são
verdadeiros, logo, teremos True como retorno;
• variavel1 and variavel2 → retorna True se AMBAS variavel1 e
variavel2 forem verdadeiras, caso contrário, False;
• Exemplo:
variavel1 = True
variavel2 = True
variavel1 and variavel2 → ambas as variáveis são verdadeiras, logo,
teremos True como retorno;

58 / 113
 ufpi cshnb

Exemplo: and

• 7 > 3 and 6 < 8 resulta em True;

• 7 > 3 and 6 > 8 resulta em False;
• 7 < 3 and 6 < 8 resulta em False;
• 7 < 3 and 6 > 8 resulta em False;

59 / 113
 ufpi cshnb

or

• O operador binário de disjunção ou ou lógico é representado

em inglês: or;
• Neste caso, se qualquer uma das expressões constituintes for
verdadeira, a expressão completa também será; Por exemplo,
a expressão “vou à praia ou vou ao campo” é verdadeira se eu
for a praia e não ao campo, sendo também verdadeira se eu
for ao campo e não a praia, e se eu for a ambos;

60 / 113
 ufpi cshnb

or

• Teste1 or Teste2 → retorna True se um ou ambos Teste1 e

Teste2 forem verdadeiros, caso contrário,False;
• Exemplo: 3 < 7 or 8 > 6 → ambos os testes são verdadeiros,
logo, teremos True como retorno;
• variavel1 or variavel2 → retorna True se uma ou ambas
variavel1 e variavel2 forem verdadeiras, caso contrário,False;
• Exemplo:
variavel1 = True
variavel2 = False
variavel1 or variavel2 → uma das as variáveis é verdadeira, logo,
teremos True como retorno;

61 / 113
 ufpi cshnb

Exemplo: or

• 7 > 3 or 6 < 8 resulta em True;

• 7 > 3 or 6 > 8 resulta em True;
• 7 < 3 or 6 < 8 resulta em True;
• 7 < 3 or 6 > 8 resulta em False;

62 / 113
 ufpi cshnb

not

• O operador unário não lógico é representado por sua versão

em inglês not;
• Tem como função inverter o valor lógico da expressão a qual
se aplica;
• É bem útil quando se quer garantir que um determinado teste
seja sempre verdadeiro ou falso antes de executar um bloco de
código;

63 / 113
 ufpi cshnb

not
• not Teste1 → retorna True se Teste1 for falso e retorna False
se Teste1 for verdadeiro;
• Exemplo: not 8 < 6 → o teste é falso, logo, teremos True
como retorno;
• Exemplo: not 8 > 6 → o teste é verdadeiro, logo, teremos
False como retorno;
• O mesmo se aplica a variáveis;
• Exemplo:
variavel1 = True
variavel2 = False
not variavel1 → a variável é verdadeira, logo, teremos False como
retorno;
not variavel2 → a variável é falsa, logo, teremos True como
retorno;
64 / 113
 ufpi cshnb

Exemplo: not

• not 7 > 3 resulta em False;

• not 7 < 3 resulta em True;

65 / 113
 ufpi cshnb

Operadores Lógicos

• Os operadores lógicos podem ser usados em conjunto;

• Por exemplo:

(4 > 9 and 6 < 8) or (not 7 < 3)

66 / 113
 ufpi cshnb

Retomando o Conceito de Variáveis

• Nome:
• descritivo;
• significativo;
• ajudar na releitura do código;
• não pode ser palavras-chave.
• Valor:
• informação armazenada;
• pode ser atualizado;

67 / 113
 ufpi cshnb

Atribuindo valores a variáveis com =

• Calcula-se o lado direito → o valor;

• Guarda-se o valor no lado esquerdo → a variável;
• O = é chamado atribuição;

x=3
x = x*x
y=x+1

68 / 113
 ufpi cshnb

Exemplos de Atribuição

• Trocando variáveis
x=1
y=2
x=y
y=x
Esse código consegue alterar os valores de x e y?

69 / 113
 ufpi cshnb

Exemplos de Atribuição

• Trocando variáveis
x=1
y=2
temp = y
y=x
x = temp

70 / 113
Strings
 ufpi cshnb

Tipos

• int
• float
• bool
• string

72 / 113
 ufpi cshnb

Strings

• letras, caracteres especiais, espaço, dígitos;

• Indicado por aspas duplas (“ ”) ou simples (’ ’):
• nome = “Maria”
• As strings podem ser concatenadas

oi = ’Boa tarde’
nome = ’Maria’
cumprimento = oi + “ ” + nome

73 / 113
 ufpi cshnb

Operações em Strings

• ’ab’ + ’cd’ → concatenação

• 3* ’ab’ → concatenação sucessiva
• len(’abcde’) → tamanho
• ’abcde’[1] → indexando (uma string funciona como um vetor
que começa no índice 0 e termina em len() - 1)
• ’abcde’[1:3] → divide a string

74 / 113
 ufpi cshnb

Exemplo

a) “a” + “bc” ..................................................

b) 3* “bc” ..................................................
c) “3” * “bc” ..................................................
d) “abcd”[2] ..................................................
e) “abcd”[0:2] ..................................................
f) “abcd”[:2] ..................................................
g) “abcd”[2:] ..................................................

75 / 113
Comandos de Entrada e Saída
 ufpi cshnb

Saída
• Para imprimirmos algum tipo de informação na tela do
computador utilizamos o comando escreva seguido da
informação que será escrita;
• Por exemplo, teríamos um estrutura parecida com
escreva (“Olá Mundo”)
ou
escreva (variável)
• As aspas servem para delimitar uma sequência de caracteres a
ser mostrado na tela da mesma forma que aparece dentro do
comando;
• As aspas em si não são impressas ou mostradas;
• Quando o comando de escrever se refere a uma variável, o que
aparece na tela é o conteúdo associado a esse identificador;

77 / 113
 ufpi cshnb

Saída

• É possível escrever valores de qualquer tipo existente, como

valores reais, valores lógicos, valores inteiros, do tipo sequência
de caracteres, resultados de expressões aritméticas, resultados
de expressões lógicas, resultados de expressões relacionais;
escreva (7/2)
escreva (3<6)
escreva (not 4>8)

78 / 113
 ufpi cshnb

print ()

• O comando print() é o comando de escrever na tela utilizado

na linguagem Python;
• Ele simplesmente mostra algo na tela que não é salvo na
forma de resultado;
• Isto é, este comando não possui um output;

79 / 113
 ufpi cshnb

print ()

• O comando print() mostra o argumento indicado entre

parênteses;
• Você pode usar o comando print() para imprimir (mostrar na
tela) uma string: print("Hello world");
• Você pode usar o comando print() para mostrar na tela o
valor de uma variável: print(x);
• Você pode usar o comando print() para acompanhar a
execução de seu código;

80 / 113
 ufpi cshnb

print ()

IMPORTANTE!
print(“x”) é diferente de print(x)
x=1
print(x)
xstring = str(x)
print(“Meu número favorito é ”, x, “.”, “x = ”, x)
print(“Meu número favorito é ” + xstring +“.” + “x = ” + xstring)

81 / 113
 ufpi cshnb

Entrada

• Também necessitamos receber informações de fora do

algoritmo, a partir da entrada padrão (em geral o teclado);
• Para realizarmos a entrada de dados, utiliza-se um comando
que permita receber informações do usuário;
• Ao utilizar esse o comando, o programador deve saber de
antemão qual a variável que irá armazenar o valor que será
fornecido pelo usuário;

82 / 113
 ufpi cshnb

input(“ ”)

• O comando input(“ ”) mostra o que está escrito entre aspas

ao usuário, de modo que este saiba o que o programa espera
receber;
• Então, ele aguarda o usuário digitar algo e apertar o botão
enter;
• Esse comando recebe o que é digitado pelo usuário na forma
de uma string ;
• O conteúdo recebido do usuário é atribuído a uma variável de
modo a ficar disponível para a utilização;
texto = input(“ Digite alguma coisa...”)
print(texto)

83 / 113
 ufpi cshnb

Soma de Dois Números

a = input("Digite o primeiro numero: ")

b = input("Digite o segundo numero: ")
soma = a + b
print("A soma de", a, "+", b, "eh igual a", soma)

84 / 113
 ufpi cshnb

• Como o input só retorna o tipo string, é necessário fazer uma

transformação de tipos;
• Logo, para o código anterior mostrar o valor da soma dos dois
valores recebidos, temos de converter os valores de a e b;
a = float(input("Digite o primeiro numero: "))
b = float(input("Digite o segundo numero: "))
soma = a + b
print("A soma de", a, "+", b, "eh igual a", soma)

85 / 113
Estruturas de Controle
 ufpi cshnb

Estruturas de Controle

• Estruturas de Condição;
• Estruturas de Repetição

87 / 113
 ufpi cshnb

Estruturas de Condição

• Estrutura de Condição Simples: se-então;

• Estrutura de Condição Composta: se-então-senão;
• Estruturas de Condição Encadeadas;

88 / 113
 ufpi cshnb

Se-então
• A estrutura de condição mais simples é a se-então;
• A <expressão-lógica> é uma expressão que deverá retornar
um valor de verdadeiro ou de falso;
• Caso o resultado dessa expressão for verdadeiro, será
executado o bloco de comandos que está dentro da estrutura;
• Caso seja falso, a execução do programa ignora o bloco de
comando e continua na linha seguinte à estrutura de condição;
• O <bloco de comandos> é uma sequência de código que será
executado somente quando o resultado da expressão lógica for
verdadeiro;

89 / 113
ufpi cshnb

90 / 113
 ufpi cshnb

Python (if)

x = int(input(’Digite a sua idade: ’))

if x >= 18:
print (’Você é maior de idade.’)

91 / 113
 ufpi cshnb

Se-então-senão

• A estrutura de condição se-então oferece a possibilidade de

executarmos uma determinada ação ou comando se o
resultado da expressão lógica for verdadeiro e de executarmos
uma ação diferente se o resultado da expressão lógica for falso;

92 / 113
ufpi cshnb

93 / 113
ufpi cshnb

94 / 113
 ufpi cshnb

Python (if-else)

x = int(input(’Digite a sua idade: ’))

if x >= 18:
print (’Você é maior de idade.’)
else:
print(’Você é menor de idade.’)

95 / 113
 ufpi cshnb

Estrutura de condição com expressão

lógica composta

96 / 113
 ufpi cshnb

if-else com lógica composta

if nota >= 7 and frequencia > 0.75:

print (’O aluno está aprovado.’)
else:
print(’O aluno está reprovado.’)

97 / 113
 ufpi cshnb

Estruturas de Condição Encadeadas

• Dentro de uma estrutura se-então-senão é perfeitamente

possível utilizarmos mais de uma linha de comando, ou até
mesmo outras estruturas se-então-senão;
• Existem situações em que os caminhos para a tomada de uma
decisão acabam formando uma espécie de árvore com diversas
ramificações, onde cada caminho é um conjunto de ações;
• Nas estruturas de decisão encadeadas, uma estrutura de
condição é aninhada dentro de outra, como bloco verdade ou
falsidade;
• Neste caso, para que a estrutura de condição mais interna seja
avaliada, é necessário que uma determinada condição seja
satisfeita na estrutura de condição mais externa;

98 / 113
ufpi cshnb

99 / 113
 ufpi cshnb

if-elif-else na estrutura encadeada

media = float(input(’Digite o valor da media: ’))

frequencia = float(input(’Digite a frequencia: ’))
if frequencia >= 0.75:
if media >= 7:
print(’Você está APROVADO.’)
elif media >= 3:
print(’Você está em RECUPERACAO.’)
else:
print(’Você está REPROVADO.’)
else:
print(’Você está reprovado por FALTAS.’)

100 / 113
 ufpi cshnb

Controle de Fluxo

• A condição tem um valor True ou False;

• O comando do bloco If só é executado se a condição for True;

101 / 113
 ufpi cshnb

Indentação

• Python é uma linguagem indentada;

• A posição do comando afeta o fluxo do programa;
• Uma linha de comando fora do lugar pode (e vai) gerar erro
de semântica;

102 / 113
Exemplos
 ufpi cshnb

1) Indique o tipo de cada uma das expressões abaixo.

a) "Olá".......................................................
b) None .......................................................
c) 4.3 .......................................................
d) -7 .......................................................
e) False .......................................................
f) 44/4 .......................................................
g) 30%3 .......................................................
h) 30//3 .......................................................
i) "8".......................................................
j) 7.0 + 3 .......................................................
k) "a"+"b".......................................................
l) 3 < 8 .......................................................

104 / 113
 ufpi cshnb

2) Indique qual o valor seria retornado pelo interpretador Python

para cada uma das expressões a seguir. No caso de erro, escreva a
palavra error como resposta. Se a resposta for um número decimal
escreva o valor completo ou até a quarta casa decimal (escolha a
menor das opções).
a) 6 – 1 + 5 .......................................................
b) 2 * 3 .......................................................
c) 2 * 3.0 .......................................................
d) - - 4 .......................................................
e) 10/3 .......................................................
f) 10.0/3.0 .......................................................
g) 2 * *3 .......................................................
h) 2.0 * *3.0 .......................................................
i) 3*2 + 3 .......................................................
j) 3*(2 + 3) .......................................................
k) 2* 4.0 .......................................................

105 / 113
 ufpi cshnb

3) A seguir temos a transcrição de uma seção no Python Shell.

Avalie cada expressão e determine o tipo e o resultado que
apareceria no Python Shell. Se você perceber que alguma
expressão dará erro responda NoneType para tipo e error para o
resultado. Assuma que as expressões são avaliadas na ordem em
que aparecem. Isto é, cada problema é avaliado logo após o
problema anterior, de modo que se utiliza de seu resultado.
a)» a = 1
» a == 5
»a
Tipo: ..................................................
Resultado: ..................................................
b)» b = 6
»c=b>9
»c
Tipo: ..................................................
Resultado: ..................................................
106 / 113
 ufpi cshnb

c)» a = 3
»d=a-7
»a
Tipo: ..................................................
Resultado: ..................................................
d)» b = 1
» e = b * 3.0
»e
Tipo: ..................................................
Resultado: ..................................................
e)» a = 2
» a = a*a
»a
Tipo: ..................................................
Resultado: ..................................................

107 / 113
 ufpi cshnb

4) Para cada expressão abaixo, especifique seu tipo e valor. Se

você perceber que alguma expressão dará erro responda Nonetype
para tipo e error para o resultado.
Assuma que foram feitas as seguintes atribuições.
» str1 = “hello”
» str2 = “,”
» str3 = “world”
a) » str1
Tipo: ..................................................
Resultado: ..................................................
b) » str1[0]
Tipo: ..................................................
Resultado: ..................................................
c) » str1[1]
Tipo: ..................................................
Resultado: ..................................................

108 / 113
 ufpi cshnb

d) » str1[-1]
Tipo: ..................................................
Resultado: ..................................................
e) » len(str1)
Tipo: ..................................................
Resultado: ..................................................
f) » str1[len(str1)]
Tipo: ..................................................
Resultado: ..................................................
g) » str1 + str2 + str3
Tipo: ..................................................
Resultado: ..................................................
h) » str1 + str2 + ‘ ‘ +str3
Tipo: ..................................................
Resultado: ..................................................

109 / 113
 ufpi cshnb

i) » str3 * 3
Tipo: ..................................................
Resultado: ..................................................
j) » “hello” == str1
Tipo: ..................................................
Resultado: ..................................................
k) » “HELLO” == str1
Tipo: ..................................................
Resultado: ..................................................
l) » “a” in str3
Tipo: ..................................................
Resultado: ..................................................

110 / 113
 ufpi cshnb

Assuma que foi a atribuição seguinte:

» str4 = str1 + str3
m)» “low” in str4
Tipo: ..................................................
Resultado: ..................................................
n) » str3[1:3]
Tipo: ..................................................
Resultado: ..................................................
o) » str3[:3]
Tipo: ..................................................
Resultado: ..................................................
p) » str3[-1]
Tipo: ..................................................
Resultado: ..................................................

111 / 113
 ufpi cshnb

q) » str1 [1:]
Tipo: ..................................................
Resultado: ..................................................
r) » str4 [1:9]
Tipo: ..................................................
Resultado: ..................................................
s) » str4 [1:9:2]
Tipo: ..................................................
Resultado: ..................................................
t) » str4 [: : 1]
Tipo: ..................................................
Resultado: ..................................................

112 / 113
 ufpi cshnb

Referências

• Introduction to Computer Science and Programming Using

Python. MITx.
• Introdução à Ciência da Computação com Python, USP;
• IME-USP, Aulas de Introdução à Computação com Python.
São Paulo: USP, 2016.
• FERRARI, F.; CECHINEL, C. Introdução à Algoritmos e
Programação, disponível em
https://www.ferrari.pro.br/home/documents/FFerrari-
CCechinel-Introducao-a-algoritmos.pdf.
• GUIMARÁES, A. M., Lages N.A. C. Algoritmos e Estrutura de
Dados. Rio de Janeiro, LTC – 1994.
• Imagens oriundas da internet.

113 / 113