Aula 1 - Introdução à Programação (UFCD 0804)
===
###### tags: `Introdução à Programação` `Introdução` `Avaliação` `Apresentação`
:::info
- **Localização:** online
- **Data:** 10 novembro 2020 18:30 (UTC)
- **Sumário**
Apresentação do docente e discussão do funcionamento geral deste módulo: horários, critérios e momento de avaliação, material de apoio e programa.
Introdução ao assunto da programação. Escrita, compilação e teste de programas na linguagem de programação C e Python, nomeadamente de várias versões do `Hello World`. Tipos de dados básicos e variáveis.
- **Contato:** Pedro R. M. Inácio (<inacio@di.ubi.pt>)
:::
## Formador
**Pedro Ricardo Morais Inácio** nasceu na Covilhã, Portugal, em 1983. Tem uma licenciatura pré-Bolonha em Matemática Informática e um Doutoramento em Engenharia Informática, obtidos na Universidade da Beira Interior (UBI) em 2005 e 2009, respetivamente. Os trabalhos de Doutoramento foram desenvolvidos no ambiente empresarial da _Nokia Siemens Networks Portugal S.A._, ao abrigo de uma bolsa de investigação da Fundação para a Ciência e a Tecnologia.
Integra o corpo docente do Departamento de Informática da UBI desde 2010, onde leciona unidades curriculares relacionadas com segurança e garantia da informação, programação de dispositivos móveis e simulação assistida por computador, a cursos de licenciatura, mestrado e doutoramento, nomeadamente aos de Engenharia Informática. É atualmente presidente do Departamento de Informática da UBI. É instrutor da Academia Cisco da UBI.
É membro sénior IEEE e investigador do Instituto de Telecomunicações (IT). Os seus interesses de investigação incluem segurança e garantia da informação, simulação assistida por computador, e monitorização, análise e classificação de tráfego de rede. Tem cerca de 30 publicações em livros, revistas e conferências científicas internacionais com revisão por pares. Revê com frequência artigos para revistas IEEE, Springer, Wiley e Elsevier. Foi membro do Comité Técnico de diversas conferências internacionais como a ACM Symposium on Applied Computing - Track on Networking. Foi um dos organizadores da WISARC 2016.
## Funcionamento das Sessões
* Algum substrato teórico: método expositivo;
* Parte prática: _hands on_;
* As partes de exposição de conteúdos serão intercaladas por períodos em que se resolvem exercícios práticos cujo objetivo é, quase sempre, implementar, compilar e testar programas em computador. Os exercícios estarão enunciados em fichas práticas. As linguagens de programação usadas para transmitir a maior parte dos conteúdos e praticar serão **C e Python**.
* [https://www.onlinegdb.com/](https://www.onlinegdb.com/)
:::warning
:warning: Todas as sessões são inteiramente **interativas**, podendo @ formand@ interromper **ordeiramente** para colocar questões, quer em períodos de exposição, quer durante a resolução de exercícios.
:::
## Critérios e Momentos de Avaliação
A avaliação será **maioritariamente** feita através de **dois** elementos:
* uma **prova de avaliação de conhecimentos escrita**; e
* um **trabalho prático**.
**A participação nas aulas e avaliação contínua vale 10%.** A prova de avaliação de conhecimentos escrita consiste num teste de escolha múltipla, a fazer na última sessão de formação. Vale 45% da nota final. O trabalho prático será feito nas penúltimas 2 horas de formação, consiste na implementação de dois ou mais programas para resolução de alguns problemas específicos, enunciados na própria aula. O trabalho prático vale 45% da avaliação.
Momentos de avaliação:
* O **teste escrito** será realizado no dia **03/12/2020** (uma quinta-feira), pelas **18h30**. Terá a duração máxima de 1 hora.
* O **trabalho prático** deve ser realizado logo de seguida (dia **03/19/2020**), das **19h30 às 21h15**. Terá uma duração máxima de 1h45.
## História da Programção
## Introdução à Programação
Há dois tipos principais de linguagens de computador:
1. Linguagens interpretadas -- neste caso, existe um programa que interpreta, em tempo real, as instruções na linguagem humana e as transforma em tempo real em instruções que o computador percebe (e.g., Python);
2. Linguagens compiladas -- neste caso, existe um programa que tranforma uma linguagem mais próxima da do humano na linguagem máquina, **e depois** é que o programa é executado (e.g., o C).
:::warning
Aparentemente, há menos 1 passo nas linguagens interpretadas!
:::
Os **compiladores** são programas que tranformam um programa escrito numa linguagem próxima à de um humano numa linguagem que um computador perceba.
Os **interpretadores** são programas que interpretam um programa escrito numa linguagem próxima à de um humano e a transformam em tempo real numa linguagem que um computador perceba.
### Processo de Programação
1. O humano escreve o programa numa linguagem de programação (é próxima à humana) num ou vários ficheiros;
2. O humano usa outro programa para transformar aquele ficheiro (ou aqueles ficheiros) numa linguagem que o computador possa reconhecer e executar (formato binário);
3. O humano corre o programa.
## Programa
**Um programa** é um conjunto de instruções bem estruturadas para atingir determinado fim num sistema computacional.
**Um algoritmo** é um conjunto bem ordenado, definido e estruturado de passos para conseguir determinado fim.
### Editores para Programação
Alguns editores de texto são próprios para programação, contendo recursos que ajudam o programador. E.g., alguns fazem _sintax hightlighing_ (i.e., colocam cores ou estilizam partes do programa).
Ambientes de Desenvolvimento Integrados - São programas, normalmente gráficos, extremamente complexos, que ajudam a escrever programas, a compilá-los e a executá-los, normalmente escondendo alguns detalhes por detrás dessas operações.
:::success
Python é uma linguagem mais elegante do que o C (tem menos *clutter*).
:::
### Tipos de Dados
As linguagens de programação definem tipos básicos de dados. Por exemplo, em C e em Java, há os `int`, `long`, `double`, `float`, `char` e vetores destes tipos. As linguagens de programação C e Java são tipadas (fortemente). Isto significa que, quando declaramos uma variável, temos dizer o seu tipo!
Em C, declarar uma variável `iNumber` para guardar um número inteiro é o mesmo que fazer o seguinte:
~~~
int iNumber;
~~~
Em C, declarar uma variável `fNumber` para guardar um número com vírgula é o mesmo que fazer o seguinte:
~~~
float fNumber;
~~~
**Em Python**, contudo, **não é necessário declarar o tipo de dados**. Assim, é preciso ter algum cuidado quando o tipo da variável é fulcral para o contexto em que se está a trabalhar. Por exemplo, o seguinte excerto de código não está correto, porque **a função `input()` devolve uma _string_, e não um decimal** (e portanto a soma não iria produzir resultado):
~~~
iNumber = input()
print(iNumber + 10)
~~~
O _Uniform Resource Locator_ (URL) seguinte contém mais informação acerca dos tipos nativos do Python: [https://www.w3schools.com/python/python_datatypes.asp](https://www.w3schools.com/python/python_datatypes.asp).
### Comentários
É possível colocar texto na forma de comentários quando se programa. Este texto não é compilado ou executado.
Em **C, em C++ ou em Java**, os comentários podem ser introduzidos junto do código usando `// comentario` ou `/* comentário */`, sendo que o primeira forma é usada para comentários em linha, e a segunda forma é usada para comentários que ocupem várias linhas.
Em Python, os **comentários em linha** podem ser colocados recorrendo a `#`, e.g.,
~~~
# Na próxima linha, iNumber fica com o tipo string
iNumber = input()
~~~
Os **comentários em linha** podem ser colocados à frente de uma instrução, e.g.,
~~~
iNumber = input() # Nesta linha, iNumber fica com o tipo string
~~~
Em Python, os comentários com várias linhas podem ser conseguidos começando-os e terminando-os com `'''` (3 plicas) ou `"""` (3 aspas), e.g.,
~~~
'''
Estas 3 linhas não são compiladas ou interpretadas...
porque estão rodeadas por plicas.
Incrível.
'''
~~~
---
Ficha Prática 1 - Algoritmos (UFCD 0804)
===
### Exercícios – Parte 1.
0. Teste o programa `Hello world` no [https://www.onlinegdb.com/](https://www.onlinegdb.com/).
1. Escreva um programa que mostre no ecrã o seguinte:
~~~
Curtes?
Totil!
~~~
Solução 1 em python:
```python=
print("Curtes?")
print('Totil!')
```
Solução 1 em python:
```python=
print("Curtes?\nTotil!")
```
2. Escreva um programa que produza o seguinte _output_:
~~~
O
l
a
m
u
n
d
o
.
~~~
**Solução 1:**
```python=
print ('O')
print (' l')
print (' a')
print (' ')
print (' M')
print (' u')
print (' n')
print (' d')
print (' o')
print (' .')
```
**Solução 2:**
```python=
print ('O\n l\n a\n \n M\n u\n n\n d\n o\n .')
```
3. Escreva um programa que mostre o seguinte no ecrã:
~~~
H
e
l
l
o
W
o
r
l
d
~~~
**Solução 1:**
```python=
print ('H\ne\nl\nl\no\nW\no\nr\nl\nd')
```
4. Escreva um programa cujo *output* seja o seguinte:
~~~
My Name in ASCII ART
********************
* Pedro Inacio *
********************
~~~
**Solução 1:**
```python=
print ('My name in ASCII ART')
print ('********************')
print ('* Pedro Inácio *')
print ('********************')
```
**Solução na Linguagem C:**
```C=
#include<stdio.h>
int main(){
printf("My name in ASCII ART");
printf("********************");
printf("* Pedro Inacio *");
printf("********************");
}
```
5. Escreva um programa que mostre no ecrã o seguinte:
~~~
Some interesting symbols:
_-\|/-_print()
0OooO0
Do not confuse number one (1) with non-capital L (l)
nor zero (0) with capital O (O)!
~~~
**Solução 1:**
```python=
print('Some interesting symbols:')
print('_-\|/-_print()')
print('0OooO0')
print('Do not confuse number one (1) with non-capital L (l)')
print('nor zero (0) with capital O (O)!')
```
**Solução em C:**
```C=
#include <stdio.h>
int main()
{
printf("Some interesting symbols:\n");
printf("_-\\|/-_print()\n");
printf("0OooO0\n");
printf("Do not confuse number one (1) with non-capital L (l)\n");
printf("nor zero (0) with capital O (O)!\n");
return 0;
}
```
### Exercícios – Parte 2
1. Escreva um programa que peça ao utilizador um número inteiro e mostre no ecrã o quadrado do número lido. A execução deve ser algo semelhante a:
~~~
Good morning master!
Which number should I square for you?
5
Result is 25. Have a good day.
~~~
**Solução 1:**
```python=
print ('Good morning master!')
print ('Which number should I square for you?')
inumber = int ( input() )
iSquare = iNumber * iNumber
iCube = i
print ('Result is ', iSquare, '. Have a good day.')
```
2. Escreva um programa que peça ao utilizador um número inteiro, `x`, e mostre no ecrã:
~~~
The subsequent number to x is x+1.
~~~
**Solução 1:**
```python=
print ('Insert an integer number:')
iNumber = int ( input() )
print('The subsequent number to', iNumber, 'is', iNumber+1, '.')
```
3. Escreva um programa que peça ao utilizador um número inteiro, entre 32 e 127, e mostre no ecrã o símbolo ASCII correspondente ao número lido, entre duas plicas. Use apenas uma variável do tipo `int`. Exemplo:
~~~
Enter an integer number between 32 and 127: 65
This number corresponds to ASCII 'A'.
~~~
Nota: pode encontrar uma tabela ASCII em http://www.asciitable.com/.
Nota 2: há uma função em Python que transforma um número inteiro num caracter ASCII - `chr(.)`.
**Solução 1:**
```python=
print("Enter an integer number between 32 and 127:")
iNumber = int( input() )
cLetter = chr (iNumber)
print("This number corresponds to ASCII '", cLetter ,"'.")
```
4. Escreva um programa que peça ao utilizador um carater e escreva no ecrã o número ASCII ao qual corresponde. Use apenas uma variável. A execução do programa deve produzir um _output_ e interação semelhante a:
~~~
Enter a letter: A
The ASCII code for this letter is 65.
~~~
Nota 2: há uma função em Python que transforma um caracter num número inteiro - `ord(.)`.
5. Existe, hoje em dia, um vasto conjunto de bibliotecas de software que estão imediatamente disponiveis para ser utilizadas aquando da implementação de programas em Python. Uma dessas bibliotecas é a bilbioteca de matemática (`math`), que contém uma vasta panóplia de funções muito úteis para cálculo. Para usarmos as funções disponibilizadas por esta biblioteca, é necessário importá-la (i.e., dizer explicitamente que a queremos utilizar) no início do programa. Isso faz-se através da inclusão da linha seguinte
~~~
import math
~~~
Este exercício tem como objetivo ajudá-lo(a) na exploração das funcionalidades desta biblioteca. Para isso, escreva um programa que peça ao utilizador um número **inteiro**, `y`, positivo e menor que 100, e mostre no ecrã:
* a quarta potência do número lido (`y ** 4`);
* a raiz quadrada do número lido (`math.sqrt(y)`);
* o logaritmo do número lido (`math.log(y)`);
* a exponencial do número lido (`math.exp(y)`).
Note que o resultado da chamada às funções anteriores é sempre um número real. O *output* e fluxo de execução do programa deve ser semelhante a:
~~~
Enter a positive integer number smaller than 100: 4
1. 4 to the power of 4: ...
2. square root of 4: 2
3. log base 10 of 4: ...
4. exp of 4: ...
~~~
**Solução 1:**
```python=
import math
print("Introduza um número inteiro maior que 0 e menor que 100:")
iNumber = int ( input () )
print("a quarta potência do número lido (", iNumber ** 4 ,")")
print("a raiz quadrada do número lido (", math.sqrt(iNumber),")")
print("o logaritmo do número lido (", math.log(iNumber),")")
print("a exponencial do número lido (", math.exp(iNumber),")")
```
6. Escreva um programa que peça ao utilizador um número **real** (tipo `float`), `y`, e mostre no ecrã:
* o número lido arredondado para cima (`math.ceil(y)`);
* o número lido arredondado para baixo (`math.floor(y)`);
* o número lido arredondado para longe de zero (`round(y)`);
* o número lido arredondado para em direção a zero (`math.trunc(y)`).
Para este conjunto de exercícios, experimente usar `y > 0` e também `y < 0` e descreva as diferenças para ambos. As funções referidas encontram-se na biblioteca `math.h`.
Existe um conjunto idêntico a este de funções para serem aplicadas a valores do tipo `double`, que diferem no nome apenas pela remoção do último f. Por exemplo, a função para arrendondar um double (para longe de zero) é `round()`, e não `round()`.
7. Escreva um programa que peça ao utilizador um número real e mostre no ecrã, separadamente, as suas partes inteira e decimal. Exemplo de `output`:
~~~
Enter a real number: 5.3
The integer part of 5.3 is 5 and the decimal part is 0.3.
~~~
8. Sabendo que a forma de transformar graus Fahrenheit em graus Celsius é dada por
$$C = (F − 32) \times 5/9,$$
escreva um programa que peça ao utilizador um valor em graus F e devolva a sua conversão para graus Celsius. A execução deve produzir um _output_ e interação semelhantes a:
~~~
Enter temperature (F): 64
The temperature is 17.8C.
~~~
**Solução 1:**
```python=
print("Enter temperature (F):")
fTemperatureF = float( input() )
fTemperatureC = ( fTemperatureF - 32.0 ) * 5.0 / 9.0
print("The temperature is", round( fTemperatureC, 2), "C.")
```
9. Escreva um programa que faça a conversão inversa do programa anterior. O funcionamento e *output* é semelhante ao exemplificado antes também.
10. Escreva um programa que peça ao utilizador um número de segundos e escreva no ecrã a quantas horas, minutos e segundos correspondem. Exemplo:
~~~
Enter number of seconds: 64
64 seconds corresponds to 00:01:04.
~~~
```python=
print("Enter number of seconds:")
iNumber = int( input() )
iTSeconds = iNumber
iHours = int( iNumber / (60*60) )
iNumber = iNumber - iHours * 60 * 60
iMinutes = int( iNumber/60 )
iNumber = iNumber - iMinutes * 60
print(iTSeconds, "corresponds to", iHours,":",iMinutes,":",iNumber)
```
Aula 2 - Introdução à Programação (UFCD 0804)
===
###### tags: `Condições` `Mecanismos Decisão` `Programa Sequêncial` `if, else, elif`
:::info
- **Localização:** _online_
- **Data:** 12 novembro 2020 18:30 (UTC)
- **Sumário**
Testes e condições na linguagem de programação Python. Critérios e mecanismos de decisão de fluxo num programa sequencial: instruções `if` , `if...else` e `if...elif...else`. Operadores lógicos e relacionais.
- **Contato:** Pedro R. M. Inácio (<inacio@di.ubi.pt>)
:::
## Testes e Condições em Python
A **tomada de decisões é um dos aspetos mais relevantes do raciocínio**, mas os programas que fizemos até agora não tomam decisões. Para que um programa possa tomar uma decisão temos de ter uma forma de programar algo como:
* Se X então Y.
Para tomar decisões é necessário verificar se algo é verdadeiro ou falso, i.e., **é necessário avaliar valores lógicos**. Algumas linguagens não têm um tipo de dados dedicado para guardar valores lógicos (e.g., a linguagem C). Em Python é possível guardar os valores lógicos `True` e `False` numa variável, e.g.,
~~~
bVouComer = True
bVouComer = False
~~~
### Operadores Relacionais
Muitas vezes, os valores lógicos aparecem no contexto de comparações entre valores, pelo que é comum introduzirem-se os operadores lógicos neste ponto da discussão.
Em Python, é possível obter um valor lógico no contexto de uma comparação de valores através dos **operadores relacionais binários** descritos na tabela seguinte:
| Operador | Nome Operador | Exemplo |
| :------: | :----------------: | :------: |
| `==` | Igual a | `a == b` |
| `>` | Maior que | `a > b` |
| `>=` | Maior ou igual que | `a >= b` |
| `<` | Menor que | `a < b` |
| `<=` | Menor ou igual que | `a <= b` |
| `!=` | Diferente de | `a != b` |
~~~
idade = 26 # esta instrução atribui o valor 26 à variável idade
idade == 26 # esta instrução compara o valor que está na variável com 26
~~~
O programa seguinte exemplifica como se podem ver os resultados da aplicação
dos operadores relacionais `==`, `>=` e `!=` a dois números especificados diretamente no código:
~~~
iNum1 = -2
iNum2 = 50
print('O resultado de iNum1 == iNum2 e', iNum1 == iNum2)
print('O resultado de iNum1 >= iNum2 e', iNum1 >= iNum2)
print('O resultado de iNum1 != iNum2 e', iNum1 != iNum2)
~~~
Neste caso, o resultado seria:
~~~
O resultado de iNum1 == iNum2 e False
O resultado de iNum1 >= iNum2 e False
O resultado de iNum1 != iNum2 e True
~~~
### Operação `if`
Como referido atrás, para que um programa possa tomar decisões, necessita da capacidade de fazer o teste
* **Se** X então Y.
Em linguagem Python, tal pode ser conseguido usando a palavra reservada `if`, que funciona da seguinte forma:
~~~
if logical_expression :
instruction(s)
~~~
* A expressão (a cláusula) tem obrigatoriamente de estar contida entre o `if` e os `:` (dois pontos);
* **Não** existe uma palavra em Python para o **então**;
* Se a expressão for **verdadeira**, a instrução que se segue ao `if` (devidamente indentada) **é executada**;
* se a expressão for **falsa**, a instrução **não é executada** e o programa continua, ignorando aquela instrução.
A titulo de exemplo, considere que queria que um programa lhe mostrasse o valor de uma variável inteira `x` caso esta fosse negativa. As seguintes linhas de código permitiam concretizar esse objetivo:
~~~
x = -2
if x < 0 :
print ("x is negative: ", x)
~~~
Se, por outro lado, quisessemos mostrar uma mensagem consoante fosse positivo ou negativo, **ainda** conseguiamos resolver da seguinte forma:
~~~
x = -5
if x <0 :
print ("x is negative!")
if x>=0 :
print ("x is positive!")
~~~
:::warning
:warning: **Por favor, repare na identação de dois espaços antes das duas instruções de `print`!**
:::
### Operação `if...else`
Como é muito frequente a necessidade de fazer um conjunto de operações caso a expressão seja verdadeira e outra diferente caso a expressão seja falsa, a linguagem Python tem previsto um mecanismo para isso: o `if ... else`. Este mecanismo utiliza-se da seguinte forma:
~~~
if logical_expression :
instruction1
else:
instruction2
~~~
:warning: **Por favor, repare na identação de dois espaços antes das duas instruções!**
O que acontece é que se a expressão lógica for avaliada como sendo verdadeira, será executada a `instruction1`, caso contrário será executada a `instruction2`. O exemplo dado anteriormente pode assim ser melhor resolvido da seguinte forma:
~~~
x = 2
if x <0 :
print ("x is negative!")
else :
print ("x is positive!")
~~~
### Blocos de Instruções
**Em Python, a indentação é :warning: crítica :warning: para o fluxo de um programa.** Quando duas instruções estão **identadas da mesma forma** significa que estão **dentro do mesmo bloco**.
Assim, se quisermos executar mais de uma instrução dependendo do resultado da avaliação de um `if`, criamos um bloco de instruções, bastando para isso colocar **um grupo de instruções com a mesma identação**. Atente no exemplo seguinte para obter uma ideia mais prática do significado deste parágrafo:
~~~
x = -2
if x < 0 :
print ("x is negative!")
print ("I repeat: x is NOT positive! OVER")
else :
print ("x is positive!")
print ("Well.. it might be zero also! OVER")
~~~
### Encadeamento de `if ... else`
Podemos necessitar de tomar algumas **decisões dependendo de outras decisões**. Esse efeito pode ser conseguido **encadeando várias instruções `if`** , umas dentro do contexto das outras.
Por exemplo, considere que quer emitir avisos só quando um número for negativo, e que esses avisos vão depender posteriormente do número ser menor ou maior do que -10:
~~~
x = -2
if x < 0 :
print ("x is negative!")
if x < -10 :
print ("OMG! x is smaller than -10!")
else:
print ("Uff! x is larger than -10!")
~~~
### Operação `if ... elif... else`
O Python inclui uma forma muito útil e compacta de testar decisões que dependem de outras, conhecida como `elif` e que, basicamente, se lê _else if_. I.e., escrever
~~~
if logical_expression_1 :
instruction1
else:
if logical_expression_2 :
instruction2
else:
instruction3
~~~
é o mesmo que escrever
~~~
if logical_expression_1 :
instruction1
elif logical_expression_2 :
instruction2
else:
instruction3
~~~
(Repare-se no formato bem mais compacto da segunda abordagem!)
Podia-se melhorar o exemplo dado na subsecção anterior da seguinte maneira (repare que o exemplo não é bem igual):
~~~
x = -2
if x >= 0:
print ("x is positive or zero!")
elif x < -10 :
print ("OMG! x is smaller than -10!")
else:
print ("Uff! x is negative, but larger than -10!")
~~~
## Operadores Lógicos
Até aqui foram apenas mencionadas (e usadas nos exemplos) expressões lógicas simples na guarda dos `if`. Mas agora considere que queria emitir um aviso se a variável `x` for menor que zero e a variável `y` for maior que 10. Podiamos usar algo semelhante a:
~~~
if x < 0 :
if y > 0 :
print ("x is negative and y is positive!")
~~~
Contudo, o Python permite **combinar várias condições** numa única expressão através do uso de **operadores lógicos**, e a tabela seguinte resume alguns operadores lógicos disponíveis:
| Operador | Nome Operador | Exemplo |
| :------: | :----------------: | :-----------------: |
| `or` | Ou lógico | `x < 0 or x > 33` |
| `and` | E lógico | `y < x and x > 20` |
| `not` | Negação Lógica | `not x` |
O exemplo apresentado dois diapositivos antes (e que envolvia dois if s) pode agora ser reescrito como se mostra a seguir:
~~~
if ( x < 0 ) and ( y > 0 ) :
print ("x is negative and y is positive!")
~~~
Para que fique claro, mostram-se aqui as tabelas de verdade dos diversos operadores lógicos. A tabela de verdade do `or` é:
| `x` | `y` | `x or y` |
| :---: | :---: | :------: |
| True | True | True |
| True | False | True |
| False | True | True |
| False | False | False |
A tabela de verdade do `and` é:
| `x` | `y` | `x and y` |
| :---: | :---: | :-------: |
| True | True | True |
| True | False | False |
| False | True | False |
| False | False | False |
E a tabela de verdade do `not` é:
| `x` | `not x` |
| :---: | :-----: |
| True | False |
| False | True |
### Precedência de Operadores Lógicos e Relacionais
Uma expressão **nem sempre é avaliada da esquerda para a direita**. A ordem pela qual uma expressão é avaliada **depende da precedência dos operadores que a compõem**. A seguinte tabela indica a precedência de operadores lógicos e relacionais, sendo a primeira linha a que corresponde à maior precedência e a última à menor:
| Operador |
| :--------------------: |
| `< <= > >= == !=` |
| `not` |
| `and` |
| `or` |
Quando o compilador ou interpretador tiver de decidir entre duas operações, vai colocar em primeiro a que tiver maior precedência. **Se tiverem igual precedência, ordena as operações da esquerda para a direita.**
De modo a por em prática (e solidificar) o conhecimento adquirido, considere as seguintes declarações e inicializações
~~~
x = 5
y = -1
z = False
w = 'A'
~~~
e indique o valor lógico das seguintes expressões:
`x > y or not z`
* [x] True
* [ ] False
* [ ] Eu sei lá...
`x > y and w == 'B'`
* [ ] True
* [x] False
* [ ] Eu hoje só já quero que isto acabe!
`x > y and not w == 'A'`
* [ ] True
* [x] False
* [ ] Eu hoje só já quero que isto acabe!
---
Ficha Prática 2 - Algoritmos (UFCD 0804)
===
### Exercícios
1. Elabore um programa que comece por definir as seguintes variáveis como sugerido:
`x=1; y=-4; z=True; w=False`
Tome as providências que achar necessárias para indique o valor lógico das expressões que se seguem:
~~~
x==y
not z
z and w
x>y or y>x
x!=0 or y>=0
x!=0 or y>=0 and not z
x==0 or y>=0
z and y>=0
w and y<=0
w and not (y>=0)
w and not y>=0
~~~
**Solução**
```python=
x=1
y=-4
z=True
w=False
print( x==y ) # False
print( not z ) # False
print( z and w ) # False
print( x>y or y>x ) # True
print( x!=0 or y>=0 ) # True or False = True
print( x!=0 or y>=0 and not z ) # True or False = True
print( x==0 or y>=0 ) # False
print( z and y>=0 ) # True and False = False
print( w and y<=0 ) # False and True = False
print( w and not (y>=0) ) # False and not False = False and True = False
print( w and not y>=0 ) # False and not False = False
```
2. Escreva um programa que pergunte ao utilizador se quer calcular a área de um triângulo ou de um rectângulo e de seguida peça os valores necessários para efetuar o cálculo escolhido e mostre o respetivo resultado. Considere o seguinte exemplo de execução:
~~~
Press 1 for triangle; any other for rectangle:
1
Insert the base: 2
Insert the height: 2
The area of the triangle is: 2.
~~~
**Solução**
```python=
print("Press 1 for triangle; any other for rectangle: ")
iOption = int (input())
if iOption == 1:
# area do triangulo
print("Insert basis:")
fBase = float (input())
print("Insert height:")
fHeight = float (input())
fArea = fBase * fHeight / 2.0
print("The area is: ", fArea)
else :
# area do retangulo
print("Insert lenght:")
fLenght = float (input())
print("Insert height:")
fHeight = float (input())
fArea = fLenght * fHeight
print("The area is: ", fArea)
```
3. Escreva um programa que peça ao utilizador uma letra entre `Y` _(Yellow)_, `G` _(Green)_, `B` _(Black)_ e `W` _(White)_, e escreva no ecrã o nome por extenso da cor respectiva. Caso o utilizador introduzir qualquer uma outra letra, deve ser impresso um viso dizendo que não foi introduzida uma das letras válidas. Use instruções `if`, `elif` e `else`. Exemplos de execução:
~~~
Enter letter: Y
Yellow!
~~~
~~~
Enter letter: X
Not a valid letter!
~~~
**Solução:**
```python=
print("Enter letter (Y, G, B, W): ")
iLetter = input()
if iLetter == 'Y' or iLetter == 'y' :
print("Yellow!")
elif iLetter == 'G' or iLetter == 'g' :
print("Green!")
elif iLetter == 'B' or iLetter == 'b' :
print("Black!")
elif iLetter == 'W' or iLetter == 'w' :
print("White!")
else:
print("Not a valid letter!")
```
4. Escreva um programa que indique, consoante o número inteiro introduzido pelo utilizador, o nome do dia da semana respetivo (considere que _1-Sunday_, _2-Monday_, etc.). Use instruções `if`, `elif` e `else` neste exercício. O fluxo de execução e output deve ser semelhante a:
~~~
Insert number from 1 to 7: 3
It is Tuesday, my dear Watson.
~~~
**Solução:**
```python=
iNumber = int( input("Insert number from 1 to 7: ") )
if iNumber == 1:
print("It is Sunday, my dear Watson.")
elif iNumber == 2:
print("It is Monday, my dear Watson.")
elif iNumber == 3:
print("It is Tuesday, my dear Watson.")
elif iNumber == 4:
print("It is Wednesday, my dear Watson.")
elif iNumber == 5:
print("It is Thursday, my dear Watson.")
elif iNumber == 6:
print("It is Friday, my dear Watson.")
elif iNumber == 7:
print("It is Saturday, my dear Watson.")
else:
print("Out of range.")
```
5. Escreva um programa que mostre o seguinte menu no ecrã, leia a opção escolhida pelo utilizador e de seguida escreva no ecrã qual foi a opção escolhida:
~~~
1-Introduzir valores
2-Apagar valores
3-Mostrar valores
0-Sair
~~~
**Solução**
```python=
print ("1-Introduzir valores\n2-Apagar valores\n3-Mostrar valores \n0-Sair")
iOpcao = int( input("Introduza opção (1, 2, 3 ou 0): ") )
if iOpcao == 1:
print("1-Introduzir valores")
elif iOpcao == 2:
print("2-Apagar valores")
elif iOpcao == 3:
print("3-Mostrar valores")
else:
print("0-Sair")
```
6. Escreva um programa que indique, consoante o mês introduzido pelo utilizador, quantos dias tem esse mês (considere que Fevereiro tem sempre 28 dias). Use instruções `if`, `elif` e `else` neste exercício. O fluxo de execução e output deve ser semelhante a:
~~~
Insert name of month: March
March has 31 days.
~~~
**Solução:**
```python=
sMonth = input("Insert name of month: ")
if ( sMonth == 'February' ) or ( sMonth == 'february' ):
print("This month has 28 days.")
elif ( sMonth == 'November' ) or ( sMonth == 'April' ) or ( sMonth == 'June' ) or ( sMonth == 'September' ):
print("This month has 30 days.")
else:
print("This month has 31 days.")
```
7. A biblioteca `random` tem várias funções úteis para gerar números pseúdo aleatórios em python. E.g.,
* a função `randint(menor, maior)` gera um número inteiro pseudo-aleatório pertencente a $\{menor, ..., maior\}$ , onde _menor_ é o menor número que pode ser gerado e _maior_ é o maior número que pode ser gerado;
* a função `uniform(menor,maior)` gera um número real pseudo-aleatório pertencente ao intervalo $[menor, maior[$.
Usando uma das funções descritas em cima, escreva um programa que crie um número aleatório no intervalo $[0, 1[$, mostrando-o no ecrã.
A seguir exemplifica-se a execução e o output do programa para o último ponto:
~~~
Random number: 0.53252
~~~
**Solução:**
```python=
import random
print("Random number: ", random.uniform(0,1))
```
8. Podemos usar o gerador mencionado na questão anterior para simular a experiência de atirar uma moeda ao ar. Implemente um programa que mostre no ecrã a palavra `Heads` se o número gerado estiver no intervalo $[0, 0.5[$, ou `Tails` se o número gerado estiver no intervalo $]0.5, 1[$. Se sair 0.5, o programa deve mostrar `Sideways! WOW!`.
A seguir exemplifica-se a execução e o _output_ do programa para o último ponto:
~~~
Random number: 0.53252
Tails.
~~~
**Solução:**
```python=
import random
fNumber = random.uniform(0, 1)
if fNumber < 0.5 :
print("Heads")
elif fNumber > 0.5 :
print("Tails")
else:
print("Sideways! WOW!")
```
9. :warning: **Esta é para @s mais corajos@s!** :warning:
Um dos tipos nativos ao Python são as **sequências de números** que, se forem contínuas, podem ser definidas com a função `range(min, max)`. Por exemplo, a instrução
~~~
variavel = [1, 2]
~~~
gera a sequência
~~~
[1,2,3,4,5,6,7,8,9,10,11,12]
~~~
Por outro lado, a função `random.sample( sequencia, num)` escolhe uma subsequência de `num` números da sequência `sequencia`.
Eventualmente, combinando a informação em cima com o conhecimento de como funciona o Euromilhões, pode construir um programa em Python que gere combinações para este jogo da sorte. Na verdade, em Python, é possível fazê-lo em apenas três linhas de código (já a contar com o `import`)...
Note que jogar no Euromilhões é o mesmo que **escolher 5 números diferentes de 1 a 50** (inclusive) **e duas estrelas numeradas de 1 a 12** (inclusive).
**Solução:**
```python=
import random
print( random.sample( range(1,51), 5 ) )
print( random.sample( range(1,13), 2 ) )
```
Sign in with Wallet
Connect another wallet