Neste ponto, você deve ser capaz de examinar as funções completas e dizer o que elas fazem. Conforme você escreve funções maiores, você pode começar a ter mais dificuldade, especialmente com erros de tempo de execução e semânticos.
Para lidar com programas cada vez mais complexos, vamos sugerir uma técnica chamada desenvolvimento incremental. O objetivo do desenvolvimento incremental é evitar longas sessões de depuração adicionando e testando apenas uma pequena quantidade de código por vez.
Como exemplo, suponha que você deseja encontrar a distância entre dois pontos, dada pelas coordenadas (x1, y1) e (x2, y2). Pelo teorema de Pitágoras, a distância é:
A primeira etapa é considerar a aparência de uma função de distância no Python. Em outras palavras, quais são as entradas (parâmetros) e qual é a saída (valor de retorno)?
Nesse caso, os dois pontos são as entradas, que podemos representar usando quatro parâmetros. O valor de retorno é a distância, que é um valor de ponto flutuante.
Já podemos escrever um esboço da função:
def distancia(x1, y1, x2, y2):
return 0.0
Obviamente, esta versão da função não calcula distâncias; sempre retorna zero. Mas está sintaticamente correto e será executado, o que significa que podemos testá-lo antes de torná-lo mais complicado. Para testar a nova função, nós a chamamos com valores de amostra:
def distancia(x1, y1, x2, y2):
return 0.0
distancia(1, 2, 4, 6) # 0.0
Escolhemos esses valores de forma que a distância horizontal seja igual a 3 e a distância vertical seja igual a 4; dessa forma, o resultado é 5 (a hipotenusa de um triângulo 3-4-5). Ao testar uma função, é útil saber a resposta certa.
Neste ponto, confirmamos que a função está sintaticamente correta e podemos começar a adicionar linhas de código. Após cada mudança incremental, testamos a função novamente. Se ocorrer um erro em qualquer ponto, sabemos onde ele deve estar - na última linha que adicionamos.
Um primeiro passo lógico no cálculo é encontrar as diferenças x2- x1 e y2- y1. Vamos armazenar esses valores em variáveis temporárias chamadas dx e dy e imprimi-los.
def distancia(x1, y1, x2, y2):
dx = x2 - x1
dy = y2 - y1
print("dx is", dx)
print("dy is", dy)
return 0.0
distancia(1, 2, 4, 6)
# dx is 3
# dy is 4
Se a função estiver funcionando, as saídas devem ser 3 e 4. Nesse caso, sabemos que a função está obtendo os parâmetros corretos e executando o primeiro cálculo corretamente. Caso contrário, existem apenas algumas linhas para verificar.
Em seguida, calculamos a soma dos quadrados de dx e dy:
def distancia(x1, y1, x2, y2):
dx = x2 - x1
dy = y2 - y1
ds_quadratica = dx ** 2 + dy ** 2
print ("ds_quadratica é:", ds_quadratica)
return 0.0
distancia(1, 2, 4, 6)
# ds_quadratica é: 25
Observe que removemos as instruções de impressão que escrevemos na etapa anterior. Um código como esse é chamado de andaime porque é útil para construir o programa, mas não faz parte do produto final. Novamente, executaríamos o programa neste estágio e verificaríamos a saída (que deve ser 25).
Finalmente, usando o expoente fracionário 0,5 para encontrar a raiz quadrada, calculamos e retornamos o resultado:
def distancia(x1, y1, x2, y2):
dx = x2 - x1
dy = y2 - y1
ds_quadratica = dx ** 2 + dy ** 2
resultado = ds_quadratica**0.5
return resultado
print(distancia(1, 2, 4, 6)) # 5.0
Se funcionar corretamente, você terminou. Caso contrário, você pode querer imprimir o valor do resultado antes da instrução de retorno.
Ao começar, você deve adicionar apenas uma ou duas linhas de código por vez. À medida que você ganha mais experiência, pode acabar escrevendo e depurando pedaços maiores. De qualquer maneira, o processo de desenvolvimento incremental pode economizar muito tempo de depuração.
Os principais aspectos do processo são:
- Comece com um programa de trabalho e faça pequenas mudanças incrementais. A qualquer momento, se houver um erro, você saberá exatamente onde ele está.
- Use variáveis temporárias para manter valores intermediários para que você possa gerá-los e verificá-los.
- Depois que o programa estiver funcionando, você pode querer remover parte da estrutura ou consolidar várias instruções em expressões compostas, mas apenas se isso não dificultar a leitura do programa.
0 Comentários