Lesson04

Instruções e sequenciação de instruções

Um programa em Ptyhon é em geral uma sequência de comandos e o interpretador de Python executa o mesmo comando a comando. Mais em concreto um programa consiste numa sequência de definições seguida de uma sequência de instruções, ou em notação BNF:

<programa> ::= <definição>* <sequência de instruções>

Veremos as definições mais tarde, consideremos para já apenas sequências de instruções, e em particular os mecanismos de controlo da ordem de execução das instruções.

Os dois tipos de controlo fundamentais são a sequenciação e o salto, os quais existem também na linguagem máquina. O Python como linguagem de alto nível oferece também outras estruturas de controlo, nomeadamente a selecção e a repetição.

A sequenciação é a estrutura de controlo mais simples e determina simplesmente que as instruções são executadas pela ordem em que aparecem no programa. Em Python, numa sequenciação de instruções, estas surgem linhas consecutivas. Assumindo que o símbolo terminal NEWLINE denota a mudança de linha, temos em notação BNF:

<sequência de instruções> ::= <instrução> NEWLINE | <instrução> NEWLINE <sequência de instruções>

Exemplo de programa com uma sequência de instruções:

valor = float(input('Valor? '))
tanb = float(input('TANB (%)? '))
juros = valor*tanb/100
print('Juros:', juros)

Se escrevermos este programa no ficheiro juros.py, podes executar o mesmo da seguinte forma?

[aplf@darkstar fp]$ python3 juros.py 
Valor? 40000
TANB (%)? 0.5
Juros: 200.0
[aplf@darkstar fp]$

Num programa em Python as linhas vazias podem ser entendidas como instruções vazias, caso em que o interpretador não realiza qualquer acção e passa à próxima linha, i.e., instrução.

Execução condicional

A execução condicional é uma das estruturas de controlo mais utilizadas e permite decidir, durante a execução do programa, se uma sequência de instruções deve ou não ser executada.

A instrução if permite a selecção entre duas ou mais alternativas. Sintaxe em notação BNF:

<instrução if> ::=
    if <condição>: NEWLINE
    <bloco de instruções>
    <outras alternativas>*
    {<alternativa final>}

<outras alternativas> ::=
    elif <condição>: NEWLINE
    <bloco de instruções>

<alternativa final> ::=
    else: NEWLINE
    <bloco de instruções>

<bloco de instruções> ::=
    INDENT <sequência de instruções> DEDENT

<condição> ::= <expressão>

Em que INDENT corresponde à indentação de todas as instruções no bloco e DEDENT ao recuo da indentação após a última instrução no bloco. A condição é em geral uma expressão que toma um valor lógico, embora possa ser uma qualquer expressão se tivermos em conta a conversão automática para valores lógicos.

Exemplo:

if idade < 18:
    print('Jovem')
else:
    print('Maior')

Notar a indentação.

Outro exemplo:

x = int(input('Introduza um número inteiro: '))

if x < 0 and x%2 == 0:
    print(x, 'é negativo e par')
elif x < 0:
    print(x, 'é negativo e ímpar')
elif x%2 == 0:
    print(x, 'é um número par')
else:
    print(x, 'é um número ímpar')

Repetição

Em programação é também frequente repetir instruções em função dos dados de entrada ou em função de determinadas condições durante a execução de um programa. Estamos naturalmente a falar de ciclos.

Um ciclo é caracterizado por uma guarda, ou seja uma condição, e pelo corpo do ciclo, ou seja um bloco de instruções. Em cada iteração, antes de se executar o corpo do ciclo, a condição de guarda é avaliada e apenas se passa à execução do corpo se essa condição for verdade. É importante que o ciclo termine, ou por interrupção do ciclo a partir do corpo do mesmo, ou garantindo que ao fim de um número finito de passos a condição de guarda é falsa. A existência de ciclos que não terminam, i.e., ciclos infinitos, é um dos erros semânticos mais comuns.

Em Python existem duas instruções que permitem especificar ciclos, a instrução while e a instrução for. Veremos agora em detalhe a instrução while.

A instrução while permite executar um bloco de instruções enquanto uma dada condição for verdadeira. Note-se que, se a condição for falsa à partida, então o bloco de instruções não é executado de todo. Note-se também que o número de iterações depende inteiramente do valor que a condição de guarda toma em função da execução das instruções no bloco, não sendo possível determinar a priori o número de iterações. A sintaxe desta instrução é a seguinte, em notação BNF:

<instrução while> ::=
    while <condição>: NEWLINE
    <bloco de instruções>

Para que o ciclo while termine, é necessário que as instruções no corpo do ciclo, i.e., no bloco de instruções, modifiquem o valor da condição para falso ao fim de um número finito de passos. Em alternativa o ciclo while pode ser interrompido se no bloco de instruções for executada a instrução break, cuja sintaxe em notação BNF é a seguinte:

<instrução break> ::= break 

Quando a instrução break é executada, o ciclo cujo corpo inclui a instrução em questão é interrompido, independentemente do valor da condição de guarda.

Exemplo:

soma = 0
x = float(input('Introduza um número (negativo para terminar): '))

while x >= 0:
    soma = soma + x
    x = float(input('Introduza um número (negativo para terminar): '))

print(soma)

Outro exemplo:

n = int(input('Introduza um número inteiro: '))
d = 2

print('Os pares de divisores de', n, 'são')

print(1,'x',n)
while True:
    if d > n//d:
        break
    elif n%d == 0:
        print(d, 'x', n//d)
    d = d + 1