Programação Aula 05

Prévia do material em texto

Programação Computacional para 
Engenharias de Energias e M Ambiente 
2018.1
Aula 05
Prof. Gisele Azevedo de A. Freitas 
Grupo de Pesquisa em Computação de Alto Desempenho do ParGO/MDCC/UFC.
Departamento de Integração Acadêmica e Tecnológica em Engenharia e Arquitetura (DIATEC)
Ementa
o Introdução à computação. 
o Sistemas de numeração. 
o Tipos básicos de dados. 
o Operadores. 
o Estruturas de controle de fluxo. 
o Tipos de dados definidos pelo usuário. 
o Manipulação de memória. 
o Funções. 
o Sistema de E/S. 
o Algoritmos. 
o Aplicações em Engenharias de Energias e Meio Ambiente. 
Variaveis em Python
 Em C 
int a; 
a= 10; 
float b; 
b= 1.2;
Entrada e Saída Python
Ricardo Jacobi
Operadores lógicos e estruturas 
condicionais• Operadores 
Os operadores lógicos são
! NÃO lógico, operação de negação (operador unário)
&& E lógico, conjunção (operador binário)
|| OU lógico, disjunção (operador binário).
Por exemplo, se quisermos testar se um número num é positivo e par, e imprimir uma 
mensagem como no exemplo anterior, podemos escrever:
 
#include<stdio.h>
void main () {
 int num;
 printf(“Digite um numero: \n”);
 scanf(“%d”, &num); 
 if (num >= 0)
 if (num % 2 == 0)
 printf("Numero par não negativo.\n”);
}
Linguagem C
Ricardo Jacobi
Estruturas condicinais
• Operadores 
Com os operadores lógicos isso pode ser simplificado:
 if ((num>=0) && (num%2 == 0))
 printf("Numero par não negativo.
\n");
A operação de negação, !, pode ser usado da seguinte forma:
!expressão lógica: O valor é a negação lógica da expressão dada. 
Por exemplo:
!0 é 1
!1 é 0
Linguagem C
Incremento e Decremento em C
Na linguagem C existe uma forma direta de 
incrementar o valor de uma variável, ou seja, 
de somar 1 ao seu valor: 
 ++x; //incrementa x antes de usar seu valor 
 x++; //incrementa x depois de ter utilizado seu valor 
Ex: #include <stdio.h> 
 main( ) 
 { 
 int x=10; 
 printf (“x=%d\n”,x++); //imprime o valor 10 
 printf (“x=%d\n”,x); //imprime o valor 11 
 printf (“x=%d\n”,++x); //imprime o valor 12 
 printf (“x=%d\n”,x); //imprime o valor 12 
 
 }
Ricardo Jacobi
Exemplo
Exemplo Uso de decisão simples. 
#include <stdio.h>
main() {
 float a, b, m;
printf(“\n Informe as duas notas obtidas: ”); 
scanf(“%f %f”, &a, &b); 
m = (a+b)/2; 
if( m >= 7.0 ) printf(“\n Aprovado por media”); 
else printf(“\n AF”); 
} 
Linguagem C
Comandos Condicionais
No exemplo anterior o comando if tinha apenas 
uma única instrução a ser executada. Para que 
possam ser executadas várias instruções é 
necessária usar a representação de instrução 
composta : 
•Uma chave aberta ( { ) 
•Uma sequência de instruções (cada uma 
terminada por ponto e vírgula ;) 
•Uma chave fechada ( } )
Operadores Aritméticos
Soma: + 
Subtração: - 
Multiplicação: * 
Divisão: / 
Resto da Divisão: % 
Na linguagem C, as operações podem ter seus 
operadores de forma combinada: 
x=x+1; x+=1; 
x=x-5; x-=5; 
x=x*(y+1); x*=y+1; 
Operadores Relacionais
Maior que: > 
Maior ou igual: >= 
Menor que: < 
Menor ou igual: <= 
Igual a: == 
Diferente: != 
Os resultados desse operadores sempre são 
Verdadeiro (número diferente de zero) ou 
Falso (número igual a zero). 
Incremento e Decremento
Na linguagem C existe uma forma direta de 
incrementar o valor de uma variável, ou seja, 
de somar 1 ao seu valor: 
 ++x; //incrementa x antes de usar seu valor 
 x++; //incrementa x depois de ter utilizado seu valor 
Ex: #include <stdio.h> 
 main( ) 
 { 
 int x=10; 
 printf (“x=%d\n”,x++); //imprime o valor 10 
 printf (“x=%d\n”,x); //imprime o valor 11 
 printf (“x=%d\n”,++x); //imprime o valor 12 
 printf (“x=%d\n”,x); //imprime o valor 12 
 }
Ricardo Jacobi
Expressão Condicional ?
• A expressão condicional “? :” é uma 
simplificação do if-else utilizada 
tipicamente para atribuições condicionais:
exp1?exp2:exp3 ≈ if (exp1) exp2; else exp3;
• Ex: implementando z = max(x, y) com: 
 if: if (x > y) z=x; else z=y; 
 ?: z = (x > y) ? x : y;
Linguagem C
Fluxo de Execução: Desvio Condicional
Comando Condicional Simples: IF [Then] 
– Estrutura decisão que permite a escolha do 
grupo de ações a ser executado quando 
determinada condição é satisfeita
14
Fluxo de Execução: Desvio Condicional
Comando Condicional Composto: IF [Then] [Else] 
• Estrutura decisão que permite a escolha entre 
dois grupos de ações a serem executado 
dependendo de se uma condição é ou não 
satisfeita.
15
Comando IF
if ( <expressão> )
 <comando>; 
else
<comando>; 
—————————————————————————————————-
if (<expressão> )
{
 <comando>; <comando>; <comando>; ...
}
else
{
 <comando>;
 <comando>;
 ...
}
16
CUIDADO 1: if (a == b) NÃO É O MESMO QUE if (a = b) !! 
CUIDADO 2: if (a > b); => NÃO COLOQUE UM ‘;’ após o parênteses da 
expressão!
Comando IF
if ( <expressão> )
 <comando>; 
else
 <comando>; 
if ( salario > 100.00)
 printf (“Salário maior que R$100,00\n”);
if ( salario == 0.00)
 printf (“Este já foi demitido faz tempo...\n”);
else
 printf (“Este ainda está sendo pago...\n”);
17
Comando IFif ( <expressão> )
 <comando>; 
else
 <comando>; 
#include <stdio.h>
void main() {
float salario;
printf (“Digite o salario: \n”);
scanf(“%f”,&salario);
if ( salario > 100.00)
 printf (“Salário maior que R$100,00\n”);
if ( salario == 0.00)
 printf (“Este já foi demitido faz tempo…\n”);
else
 printf (“Este ainda está sendo pago…\n”);
}
18
IFs aninhado
• É possível aninhar 
construções do tipo if- 
else em diversos níveis: 
– O if aninhado é 
simplesmente um if dentro 
da declaração de um outro 
if mais externo 
– O único cuidado que 
devemos ter é o de saber 
exatamente a qual if um 
determinado else está 
ligado.
19
if (cond1)
 if (cond2)
 comandos if2;
 else
 comandos else2;
else
 if (cond3)
 if (cond4)
 comandos if4;
 else
 comandos 
else4;
 else
 comandos else3;
Encadeamento de IF-ELSE-IF
• No encadeamento apenas um dos n 
comandos será executado: o primeiro cujo 
teste for verdadeiro
20
if (teste_1) <comando_1>; 
else if (teste _2) <comando _2>; 
else if (teste _3) <comando _3>; 
. . . 
else <comando _n>;
• A estrutura if-else-if é apenas uma extensão da 
estrutura if-else. Sua forma geral é:
21
Encadeamento de IF-ELSE-IF
if (condição_1) {
 seqüência_de_comandos_1; 

}
else if (condição_2) {
 seqüência_de_comandos_2;
}
. . .
else if (condição_n) {
 seqüência_de_comandos_n;
}
else {
 seqüência_de_comandos_default;
}
#include "stdio.h" 
double F (int i) { 
 if (i > 100) return 1; 
 else return 1+i / (2.0*i+1) * F(i+1); 
} 
int main() { 
 printf(“PI = %f\n", 2*F(1)); 
 return 0; 
}
Linguagem estruturada
22
23
PYTHON
24
25
26
27
28
29
30
>>> salario = float(80) 
>>> if salario < 100: print (“Salario abaixo da media”) 
>>> salario = float (input (“Digite o salario")) 
>>> if salario < 100: print (“Salario abaixo da media")
Comandos Condicionais
Existe ainda uma estrutura condicional para 
casos de seleção múltipla: o switch - case. 
switch(variável) 
{ 
 case valor1: 
 comandos 1; 
 break; 
 case valor2: 
 comandos 2; 
 break; 
 ... 
 default: 
 comandos; 
}
Comandos Condicionais
Comparando com algoritmo temos: 
 switch (variável) 
escolha variável { 
 caso valor1 case valor1: 
 comandos 1 comandos 1; 
 caso valor2 break; 
 comandos 2 case valor2: 
 ... comandos 2; 
 outrocaso break; 
 comandos ... 
fimescolha default: 
 comandos; 
 }
Comandos Condicionais
Ex: 
#include<stdio.h> 
main() 
{ 
 int x; 
 printf("1. incluir\n"); 
 printf("2. alterar\n"); 
 printf("3. excluir\n"); 
 printf("Digite sua opção:");scanf(“%d”,&x); 
 switch(x) 
 { 
 case 1: 
 printf("escolheu inclusão\n"); 
 break; 
 case 2: 
 printf("escolheu alteração\n"); 
 break; 
 case 3: 
 printf("escolheu exclusão\n"); 
 break; 
 default: 
 printf("opção inválida\n"); 
 } 
}
Ricardo Jacobi
Exercicio
1.Qual a saída produzida pela instrução a seguir? 
printf("%d %d %d %d", !3, !0, 3+'a'>'b'+2 && !'b', 1 || !2 && 3); 
2.Dados dois números distintos, informe qual dele é o maior. 
3.Dado um ano, informe se ele é ou não bissexto. [Dica: um ano é 
bissexto se é divisível por 4 mas não por 100]. 
Linguagem C
35
Estrutura de repetição
• Comando for 
 for (var=valor inicial; condição; incremento) 
 comando; 
 for (var=valor inicial; condição; incremento) 
 { 
 comando1; 
 comando2 
 comando3; 
 }
Pseudo-código: 
Para CONT = 3 até 11 repetir 
Mostrar CONT
Exemplo: 
for (cont=3; cont<=11; cont++) 
 printf (“%d”,cont);
Fluxo de um programa em C: FOR
36
Fluxo de Execução de um Programa => Repetição FOR
for (<início>; <teste condição final> ; <ajuste fim>) 
{ comandos; }
FOR: Para que a variável varie do valor de inicio até o valor 
de final
Fluxo de um programa em C: FOR
37
Fluxo de Execução de um Programa => COM Repetição (LAÇOS)
Fluxo Sequencial: SEM DESVIOS! 
 
Fluxo com Laços: COM DESVIOS!
Comando de Laço FOR
38
Comando de Laço FOR
39
for ( <expr_inicial>; <condição_de_parada>; 
<alteração_var_controle> )
 <comando>;
for ( contador=0; contador < nro_vezes; contador++ )
 printf(“Contando... %d\n”, contador);
for (contador=10; contador != 0; contador-- )
{
 printf(“Contagem regressiva...\n”);
 printf(“Falta: %d \n”, contador);
}
Cuidado 1: for ( a=1; a <= 10; a++) ; 
Cuidado 2: for ( ; ; ) /* Loop infinito */
Comandos de Repetição
Comparando com algoritmo temos: 
para variável de valor-inicial ate 
valor-fim faca

 comando

fimpara 
for(inicialização; condição; 
incremento) 
 comando; 
Comandos de Repetição
Problema: Imprime valores de 1 a 100 um em 
cada linha. 
Comandos de Repetição
Ex: Imprime valores de 1 a 100 um em cada 
linha. 
#include<stdio.h> 
main() 
{ 
 int x; 
 for(x=1;x<=100;x++) 
 printf("%d\n",x); 
} 
Obs: para mais de um comando não esquecer 
de usar a instrução composta com { e }
Comandos de Repetição
Outros exemplos: 
✓Para mudar o valor da variável de 2 em 2 
for(x=1;x<100;x=x+5) 
 printf("%d\n",x); 
✓Para usar mais de uma variável de controle 
no mesmo comando for 
Comandos de Repetição
 
✓Para usar mais de uma variável de controle 
no mesmo comando for 
for (x=0,y=0;x+y<100;++x,++y) 
 printf(“x=%d, y=%d, x+y=%d\n”,x,y, x
+y);
Comandos de Repetição - FOR
for (x=0,y=0;x+y<100;++x,++y) 
 printf("%d ",x+y);
Comandos de Repetição
47
Exercícios
7)Sendo h= 1 + ½ + 1/3 + ¼ + ... + 1/N, prepare um 
algoritmo para calcular o número h, sendo o número 
N fornecido pelo usuário. 
8) Elabore um algoritmo que calcule N! (fatorial de N), 
sendo que o valor inteiro de N é fornecido pelo 
usuário. Sabendo que: 
• N! = 1 x 2 x 3 x ... x (N-1) x N; 
• 0! = 1, por definição. 
9)Faca um programa que apresente na tela a tabela de 
conversão de graus Celsius para Fahrenheit, de -100 
C a 100 C. Use um incremento de 10 C. 
• OBS: Farenheit = (9/5)*(Celsius) + 32
48
Exercícios
10)Escreva um programa que coloque os 
números de 1 a 100 na tela na ordem 
inversa (começando em 100 e 
terminando em 1). 
11) Calcular e listar todos os múltiplos 
positivos do número 7 menores ou 
iguais a 100. 
12 ) Calcular 
Pergunta: quantas vezes executa a 
fórmula?
49
Estrutura de repetição
• Comando while 
 
 while (condição) 
 comando; 
 while (condição) { 
 comando1; 
 comando2 
 comando3; 
 }
Exemplo: 
#include<stdio.h> 
main () { 
int N=1; 
while (N != 0) { 
 printf(“Digite um numero: 
”); 
 scanf ("%d",&N); 
 printf(“%d\n”,N); 
 } 
}
Exemplo: 
#include<stdio.h> 
main () { 
int N=1; 
while (N <= 100) { 
 printf(“%d\n”,N++); 
 } 
}
50
Exercício
12 )Fulano tem 1,50 metro e cresce 2 centímetros por 
ano, enquanto Ciclano tem 1,10 e cresce tem 3 
centímetros por ano. Construa um programa que 
calcule e imprima quantos anos serão necessários 
para que Ciclano seja maior que Fulano.
51
Estrutura de repetição
• Comando do...while 
 do { 
 comando 
 } while (condição); 
 do { 
 comando1; 
 comando2 
 comando3; 
 } while (condição);
Em pseudo-código: 
CONTADOR = 0 
Repetir 
CONTADOR = CONTADOR + 1 
exibir CONTADOR 
enquanto CONTADOR < 10
Exemplo: 
#include <stdio.h> 
main() { 
int cont=0; 
do { 
 cont = cont + 1; 
 printf("%d\n",cont); 
} while (cont < 10); 
}
Ricardo Jacobi
PYTHON
Loops com FOR e WHILE
Em algumas situações, é comum que uma mesma instrução (ou 
conjunto delas) precise ser executada várias vezes seguidas. 
Nesses casos, normalmente utilizamos um loop (ou laço de 
repetição), que permite executar um bloco de código repetidas vezes, 
enquanto uma dada condição é atendida.
Linguagem C
Ricardo Jacobi
PYTHON
Loops com FOR e WHILE
Em Python, os loops são codificados por meio dos comandos for e 
while. O primeiro nos permite percorrer os itens de uma coleção e, 
para cada um deles, executar um bloco de código. Já o while, executa 
um conjunto de instruções várias vezes enquanto uma condição é 
atendida.
Linguagem C
Repeated Steps
Output:
5
4
3
2
1
Lanxamento 
0
Program:
n = 5
while n > 0 :
 print (n)
 n = n – 1
print (‘Lancamento!’)
print (n)
n > 0 ?
n = n -1
Loops (repeated steps) have iteration variables that change each time through a loop. Often 
these iteration variables go through a sequence of numbers.
No
print 
'Lancamento
Yes
n = 5
print n
An Infinite Loop
n = 5
while n > 0 :
 print 'Lava’
 print 'Enxagua'
print ‘Seca!'
n > 0 ?
No
print 'Dry 
off!'
Yes
n = 5
print 
'Lather'
print 'Rinse'
What is wrong with this loop?
Another Loop
n = 0
while n > 0 :
 print (‘Lava’)
 print (‘Enxagua’)
print (‘Seca!’)
n > 0 ?
No
print 'Dry 
off!'
Yes
n = 0
print 
'Lavagem'
print 
'Enxague'
What does this loop do?
57
Exercícios
8) Elabore um algoritmo que calcule N! (fatorial de N), sendo que o valor inteiro de N é 
fornecido pelo usuário. Sabendo que: 
• N! = 1 x 2 x 3 x ... x (N-1) x N; 
• 0! = 1, por definição. 
# include <stdio.h> 
int main() { 
 int n, fat=1,cont; 
 printf("Digite um numero inteiro para ser calculado o seu fatorial:\n"); 
 scanf("%d",&n); 
 for (cont=1;cont<=n;cont++) 
 { 
 printf(“fat = fat (%d) * cont(%d)\n”, fat, cont); 
 fat=cont*fat; 
 printf(“fat = %d \n”, fat); 
 } 
printf("O fatorial de %d e igual a:%d",n,fat); 
return 0; 
} 
58
Exercícios
8) Elabore um algoritmo que calcule N! (fatorial de N), sendo 
que o valor inteiro de N é fornecido pelo usuário. Sabendo 
que: 
• N! = 1 x 2 x 3 x ... x (N-1) x N; 
• 0! = 1, por definição. 
n = int(input("Digite o numero n para 
calcular o fatorial: \n")) 
fat = 1 
for i in range(1,n+1): 
 fat = fat*i 
print("O numero fatorial é: ” + str(fat)) 
59
Exercícios
7)Sendo h= 1 + ½ + 1/3 + ¼ + ... + 1/N, prepare um algoritmo para 
calcular o número h, sendo o número N fornecido pelo usuário. 
#include<stdio.h> 
int main() { 
 
 float h=0,cont, n; 
 printf("Digite um numero inteiro para ser calculado o seu 
fatorial:\n"); 
 scanf("%f",&n); 
 for (cont=1;cont<=n;cont++) 
 { 
 h = h + 1/cont; 
} 
printf("O h de %f e igual a:%f",n,h); 
return 0; 
}
60
Exercícios
7)Sendo h= 1 + ½ + 1/3 + ¼ + ... + 1/N, prepare um 
algoritmo para calcular o número h, sendo o número 
N fornecido pelo usuário. (PYTHON) 
n = int(input("Digite o numero n de vezes: 
\n")) 
h = 0 
for i in range(1,n+1): 
 h = h + 1/i 
print("O numero h é: “+ str(h))
Saindo de um Loop com break
whileTrue:
 line = input(‘Digite um texto: ')
 if line == 'fim' :
 break
 print (‘Texto: ’ + line)
print (‘Fim!’)
> hello there
hello there
> finished
finished
> done
Done!
Finalizando a Iteração com 
continue
• O comando continue finaliza a corrente iteração e pula 
to the top of the loop and starts the next iteration
while True:
 line = input('> ')
 if line[0] == '#' :
 continue
 if line == 'fim' 
: break
 print line
print 'Fim!'
> alo mundo
alo mundo
> # não imprima isso
> imprima isso!
imprima isso!
> fim
Fim!
Saindo de um Loop
• A palavra reservada break termina o loop corrente e pula para 
o comando imediatamente seguindo o laço
• É como um teste de laço que pode acontecer em qualquer no 
corpo do laço
while True:
 line = raw_input('> ')
 if line == 'done' :
 break
 print line
print 'Done!'
> hello there
hello there
> finished
Finished
> done
Done!
Finalizando uma Iteração com 
continue
• O comando continue termina a iteração corrente e 
salta para o topo do loop e inicia a próxima iteração
while True:
 line = raw_input('> ')
 if line[0] == '#' : 
 continue
 if line == 'done' :
 break
 print line
print 'Done!'
> hello there
hello there
> # don't print this
> print this!
print this!
> done
Done!
True ?
No
print 'Done'
Yes
....
...
while True: 
 line = raw_input('> ’)
 if line[0] == '#' :
 continue
 if line == 'done' :
 break
 print line
print 'Done!'
....
...
continue
Loops indefinidos
• Enquanto loops são chamados “loops indefinidos" porque 
eles keep going until a logical condition becomes False
• loops we have seen so far are pretty easy to examine to 
see if they will terminate or if they will be "infinite loops"
• Sometimes it is a little harder to be sure if a loop will 
terminate
Definite Loops
• Quite often we have a list of items of the lines in a file - effectively 
a finite set of things
• We can write a loop to run the loop once for each of the items in 
a set using the Python for construct
• These loops are called "definite loops" because they execute an 
exact number of times
• We say that "definite loops iterate through the members of a set"
A Simple Definite Loop
for i in [5, 4, 3, 2, 1] :
 print i
print 'Blastoff!'
5
4
3
2
1
Blastoff!
A Definite Loop with Strings
friends = ['Joseph', 'Glenn', 'Sally']
for friend in friends : 
 print 'Happy New Year:', friend
print 'Done!'
Happy New Year: Joseph 

Happy New Year: Glenn
Happy New Year: Sally
Done!
A Simple Definite Loop
for i in [5, 4, 3, 2, 1] :
 print i
print 'Blastoff!'
5
4
3
2
1
Blastoff!
Done?
Yes
print 'Blast 
off!'
print i
No
Move i 
ahead
Definite loops (for loops) have explicit iteration variables that change each time through a 
loop. These iteration variables move through the sequence or set. 
Looking at In...
• The iteration variable 
“iterates” though the 
sequence (ordered set)
• The block (body) of code 
is executed once for each 
value in the sequence
• The iteration variable 
moves through all of the 
values in the sequence
for i in [5, 4, 3, 2, 1] :
 print i
Iteration variable
Five-element sequence
Done?
Yes
print i
No
Move i 
ahead
• The iteration variable “iterates” though the sequence 
(ordered set)
• The block (body) of code is executed once for each value 
in the sequence
• The iteration variable moves through all of the values in 
the sequence
for i in [5, 4, 3, 2, 1] 
: print i