| | | | |

3 Elementos da Programação Estruturada

Compre o e-book deste material aqui!

Na programação estruturada, os comandos de programação são executados em sequência, um novo comando só iniciado após o término do processamento do comando anterior. Em Python, cada linha consiste em um comando, o programa tem início na primeira linha e término na última linha do código. Instruções de ramificação permitem a seleção on-the-fly de blocos de comandos, enquanto que instruções de repetição permitem a execução repetida de um bloco. A definição de função permite a criação de um sub-código (sub-programa) do código.

3.1 Ramificação

Uma estrutura de ramificação é uma instrução if-[elif-...-elif-else] para a tomada de decisões durante a execução de um programa.

3.1.1 if

Por exemplo, o código abaixo computa as raízes reais do polinômio

p(x)=ax2+bx+c, (19)

com a, b e c alocados no início do código.

1import math as m
2a = 1.
3b = -1.
4c = -2.
5dlta = b**2 - 4.*a*c
6if (dlta >= 0.):
7  x1 = (-b - m.sqrt(dlta))/(2.*a)
8  x2 = (-b + m.sqrt(dlta))/(2.*a)
9  print('x1 =', x1)
10  print('x2 =', x2)
x1 = -1.0
x2 = 2.0

Neste código, o bloco de comandos (linhas 7-10) só é executado, se o discriminante do polinômio seja não-negativo. Verifique! Troque os valores de a, b e c de forma que p tenha raízes complexas.

Observação 3.1.1.

(Indentação.) Nas linhas 7-10 do código anterior, a indentação dos comandos é obrigatória. O bloco de comandos indentados indicam o escopo da instrução if.

3.1.2 if-else

Vamos modificar o código anterior, de forma que as raízes complexas sejam computadas e impressas, quando for o caso.

1import math as m
2a = 1.
3b = -4.
4c = 8.
5dlta = b**2 - 4.*a*c
6if (dlta >= 0.):
7  # raízes reais
8  x1 = (-b - m.sqrt(dlta))/(2.*a)
9  x2 = (-b + m.sqrt(dlta))/(2.*a)
10else:
11  # raízes complexas
12  rea = -b/(2.*a)
13  img = m.sqrt(-dlta)/(2.*a)
14  x1 = rea - img*1j
15  x2 = rea + img*1j
16print('x1 =', x1)
17print('x2 =', x2)
x1 = (2-2j)
x2 = (2+2j)
Observação 3.1.2.

(Número Complexo.) Em Python, números complexos podem ser alocados como objetos da classe complex. O número imaginário i=1 é denotado por 1j e um número completo a+bi por a + b*1j.

3.1.3 if-elif-else

A instrução elif é uma conjunção de uma sequência de instruções textttelse-if. Vamos modificar o código anterior, de forma a computar o caso de raízes reais duplas de forma própria.

1import math as m
2a = 1.
3b = 2.
4c = 1.
5dlta = b**2 - 4.*a*c
6if (dlta > 0.):
7  # raízes reais
8  x1 = (-b - m.sqrt(dlta))/(2.*a)
9  x2 = (-b + m.sqrt(dlta))/(2.*a)
10elif (dlta == 0.):
11  x1 = x2 = -b/(2.*a)
12else:
13  # raízes complexas
14  rea = -b/(2.*a)
15  img = m.sqrt(-dlta)/(2.*a)
16  x1 = rea - img*1j
17  x2 = rea + img*1j
18print('x1 =', x1)
19print('x2 =', x2)
x1 = -1.0
x2 = -1.0
Exercício 3.1.1.

Desenvolva um código para computar a raiz do polinômio

f(x)=ax+b (20)

com dados a e b. O código deve lidar com todos os casos possíveis, a saber:

  1. a)

    única raiz (a0).

  2. b)

    infinitas raízes (a=b=0).

  3. c)

    não existe raiz (a=0 e b0).

Resposta.
1# params
2a = 2.
3b = 1.
4# raiz
5if (a != 0.):
6  x = -b/a
7  print('raiz única x = ', x)
8elif (b == 0.):
9  print('infinitas raízes x')
10else:
11  print('não existe raiz')
Exercício 3.1.2.

Desenvolva um código em que dados três pontos A, B e C no plano, verifique se ABC determina um triângulo. Caso afirmativo, classifique-o como um triângulo equilátero, isósceles ou escaleno.

Resposta.
1import math
2# pts
3A = (0., 0.)
4B = (3., 0.)
5C = (3., 4.)
6# compr. lados
7lado_1 = math.sqrt((B[0]-A[0])**2 + (B[1]-A[1])**2)
8lado_2 = math.sqrt((C[0]-B[0])**2 + (C[1]-B[1])**2)
9lado_3 = math.sqrt((C[0]-A[0])**2 + (C[1]-A[1])**2)
10# triangulo?
11if (lado_1 + lado_2 > lado_3) and \
12    (lado_1 + lado_3 > lado_2) and \
13    (lado_2 + lado_3 > lado_1):
14  print('ABC é triângulo:')
15  # equilátero?
16  if lado_1 == lado_2 == lado_3:
17    print('\tequilátero')
18  elif (lado_1 != lado_2 != lado_3):
19    print('\tescaleno')
20  else:
21    print('\tisósceles')
22else:
23  print('ABC não é triângulo')

3.2 Repetição

Estruturas de repetição são instruções que permitem que a execução repetida de um bloco de comandos. São duas instruções disponíveis while e for.

3.2.1 while

A instrução while permite a repetição de um bloco de comandos, enquanto uma dada condição for verdadeira.

Por exemplo, o seguinte código computa e imprimi os elementos da sequência de Fibonacci55endnote: 5Leonardo Fibonacci, 1170 - 1250, matemático italiano. Fonte: Wikipédia: Leonardo Fibonacci., enquanto forem menores que 10.

1n = 1
2print(n)
3m = 1
4print(m)
5while (n+m < 10):
6  s = m
7  m += n
8  n = s
9  print(m)

Verifique!

Observação 3.2.1.

(Instruções de Controle.) As instruções de controle break, continue são bastante úteis em várias situações. A primeira, encerra as repetições e, a segunda, pula para uma nova repetição.

Exercício 3.2.1.

Use while para imprimir os dez primeiros números ímpares.

Resposta.
1i = 1
2c = 0
3while (c < 10):
4  print(i)
5  i += 2
6  c += 1
Exercício 3.2.2.

Uma aplicação do Método Babilônico66endnote: 6Matemática Babilônica, matemática desenvolvida na Mesopotâmia, desde os Sumérios até a queda da Babilônia em 539 a.C.. Fonte: Wikipédia. para a aproximação da solução da equação x22=0, consiste na iteração

x0=1, (21)
xi+1=xi2+1xi,i=0,1,2, (22)

Faça um código com while para computar aproximação xi, tal que |xi+1xi|<107.

Resposta.
1import math
2x0 = 1.
3x = x0/2 + 1/x0
4while (math.fabs(x - x0) >= 1e-7):
5  x0 = x
6  x = x0/2 + 1/x0
7print(x)

3.2.2 for

A instrução for permite a execução iterada de um bloco de comandos. Dado um objeto iterável, a cada laço um novo item do objeto é tomado. Por exemplo, o seguinte código computa e imprime os primeiros 6 elementos da sequência de Fibonacci.

1n = 1
2print(f'1: {n}')
3m = 1
4print(f'2: {m}')
5for i in [3,4,5,6]:
6  s = m
7  m += n
8  n = s
9  print(f'{i}: {m}')

Verifique!

3.2.3 range

A função range([start,]stop[,sep]) é particularmente útil na construção de instruções for. Ela cria um objeto de classe iterável de start (incluído) a stop (excluído), de elementos igualmente separados por sep. Por padrão, start=0, sep=1 caso omitidos. Por exemplo, o código anterior por ser reescrito como segue.

1n = 1
2print(f'1: {n}')
3m = 1
4print(f'2: {m}')
5for i in range(3,7):
6  s = m
7  m += n
8  n = s
9  print(f'{i}: {m}')

Verifique!

Exercício 3.2.3.

Com n dado, desenvolva um código para computar o valor da soma harmônica

k=1n1k=11+12++1n. (23)
Resposta.
1n = 10
2s = 0.
3for i in range(1,n+1):
4  s += 1./i
5print(s)
Exercício 3.2.4.

Desenvolva um código para computar o fatorial de um dado número natural n. Dica: use math.factorial para verificar seu código.

Resposta.
1n = 5
2fact = 1
3for i in range(1, n+1):
4  fact *= i
5print(fact)

3.3 Funções

Em Python, uma função é definida pela instrução def. Por exemplo, o seguinte código implementa a função

f(x)=2x3 (24)

e imprime o valor de f(2).

1  def f(x):
2  y = 2*x - 3
3  return x
4
5z = f(2)
6print(f'f(2) = {z}')
f(2) = 2
Observação 3.3.1.

Para funções pequenas, pode-se utilizar a instrução lambda de funções anônimas. Por exemplo,

1f = lambda x: 2*x - 3
2print(f'f(3) = {f(3)}')
f(3) = 3
Exemplo 3.3.1.

(Função com Parâmetros.) O seguinte código, implementa o polinômio de primeiro grau

p(x)=ax+b, (25)

com parâmetros predeterminados a=1 e b=0 (função identidade).

1def p(x, a=1., b=0.):
2  y = a*x + b
3  return y
4
5print('p(2) =', p(2.))
6print('p(2, 3, -5) =', p(2., 3., -5.))
Exercício 3.3.1.

Implemente uma função para computar as raízes de um polinômio de grau 2 p(x)=ax2+bx+c.

Resposta.
1import math
2def raiz_poli2(a, b, c):
3  dlta = b**2 - 4.*a*c
4  if (dlta > 0.):
5    x1 = (-b + math.sqrt(dlta))/(2.*a)
6    x2 = (-b - math.sqrt(dlta))/(2.*a)
7  elif (dlta == 0.):
8    x1 = -b/(2.*a)
9    x2 = x1
10  else:
11    x1 = None
12    x2 = None
13  return x1, x2
Exercício 3.3.2.

Implemente uma função que computa o produto escalar de dois vetores

x=(x0,x1,,xn1), (26)
y=(y0,y1,,yn1). (27)

Dica: considere que os vetores são alocados com lists.

Resposta.
1def dot(x, y):
2  s = 0.
3  for xi, yi in zip(x,y):
4    s += xi*yi
5  return s
Exercício 3.3.3.

Implemente uma função que computa o determinante de matrizes 2×2. Dica: considere que a matriz está alocada com um list encadeado.

Resposta.
1def det(A):
2  d = A[0][0]*A[1][1] \
3    - A[0][1]*A[1][0]
4  return d
Exercício 3.3.4.

Implemente uma função que computa a multiplicação matriz - vetor Ax, com A matriz 2×2 e x um vetor de dois elementos. Assuma que a matriz e o vetor estão alocados usando list.

Resposta.
1def matVet(A, x):
2  n = len(A)
3  y = [0.]*n
4  for i in range(n):
5    for j in range(n):
6      y[i] += A[i][j]*x[j]
7  return y

Envie seu comentário

As informações preenchidas são enviadas por e-mail para o desenvolvedor do site e tratadas de forma privada. Consulte a Política de Uso de Dados para mais informações. Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!