Introdução à computação 3

Escrevendo procedimentos

comandos

Como já vimos nosso ambiente ou espaço de trabalho é povoado de dados de diversos tipos. Para escrever procedimentos precisaremos de comandos que nos permitam manipular estes dados. Um procedimento será expresso como uma sequencia ordenada de instruções ou comandos.

E quem executa tais comandos? Bem, ultimamente o computador é quem  executa qualquer coisa mas entre nosso procedimento e a máquina podem existir diversas camadas de outros programas que manipulam o texto do procedimento e produzem outros textos modificados, os quais são passados para outros programas e assim por diante. Eventualmente nosso texto original acaba transformado num conteúdo que é diretamente executável pela máquina. 

Este processo é chamado de compilação e o texto final, supostamente uma tradução fiel de nosso procedimento, é um arquivo executável, ganhando a terminação .exe 

Um outro processo de transformação, que é usado pelo Python, depende de existir um programa interpretador, o qual examina nosso procedimento e para cada um de nossos comandos gera ações correspondentes na máquina. Neste caso não é produzido um arquivo executável tipo .exe. Em vez disso nosso texto original será interpretado pelo interpretador, a cada nova execução de nosso programa.

E porquê toda esta manipulação? Porquê não interpretar nosso procedimento diretamente, sem intermediários?

A causa disto é a enorme diferença de níveis conceituais entre o programador, um ser humano, e a máquina. Sem entrar na descrição dos componentes internos do computador e como são executados comandos, basta dizer que  os conceitos na linguagem de máquina são muito elementares e distantes de nosso ambiente de trabalho. Instruções de máquina tratam de coisas como carregar bytes em registradores internos, mover bytes nestes registradores, efetuar operações binárias básicas entre grupos de bits e assim por diante.

A função das diversas camadas de programas mencionadas acima é traduzir nosso procedimento original em uma sequência, bem mais extensa, de instruções na linguagem de máquina. Ou então interpretar o procedimento, como já dito.

Neste curso iremos estudar a linguagem Python para escrever nossos procedimentos. Python é uma linguagem interpretada.

tipos de comandos

 A experiência mostra que bastam cinco tipos de comandos para exprimir a maioria dos algorítmos:

• Entrada
• Saída
• Atribuição
• Contrôle do fluxo de execução
• Repetição

Comandos de entrada típicos permitem lêr dados externos para alimentar o procedimento. Aí haverão comandos de leitura de arquivos, entrada pelo teclado, acesso à internet,  etc. Por exemplo:

Leia(arquivo)

Comandos de saída permitem o procedimento escrever em impressora ou no display, além de registrar dados  em arquivos ou envia-los pela internet.

Imprima(texto)

Comandos de atribuição são aquêles que associam objetos a variáveis.

soma = 0

y = 7

x = y

Comandos de contrôle do fluxo de execução. Todo procedimento tem um fluxo de execução implicito, pois é uma sequência ordenada de comandos. Entretanto pode ser necessário mudar esta ordem natural pulando para ou repetindo outros trechos do procedimento dependendo de certas condições no ambiente do trabalho. Por exemplo, este procedimento para encher um barril de água:

1.  abra a torneira 
2. deixe encher por 10 segundos
3. feche a torneira
4. verifique o nível no barril. 
5. se nivel alcançou o desejado, pare.
6. se não, vá para o passo 1.

Comandos de repetição. Frequentemente um procedimento envolve a execução de um mesmo grupo de comandos repetidas vezes, até que alguma condição seja satisfeita. Obviamente é pouco prático e enfadonho escrever repetição do mesmo grupo de comandos. Para tanto temos os comandos de repetição. Tipicamente são de dois tipos:

• para cada x que satisfaz alguma propriedade:
  
             grupo de comandos a executar
• enquanto certa condição não ocorrer:
  
              grupo de comandos a executar

expressões

Além de comandos precisamos de expressões. Expressões são usadas para comparações, tais como

x < 3                                # x é menor que 3
y >= x                              # y é maior ou igual a x
x == 127                          # x é igual a 127

Observe que para testar igualdade usamos o operador == (dois sinais de igual consecutivos). Isto porque usamos o sinal de igual para indicar atribuição, como em x = 123.

Expressões tem uma característica comum: seu valor é verdadeiro ou falso.

Estamos prontos para escrever alguns procedimentos usando este conjunto informal de comandos, mas antes vamos ver o que é pseudo-código e para que serve.