| | | | |

4.2 Definindo Funções

Compre o e-book deste material aqui!

Em Python, criamos ou definimos uma função com a instrução def, com a seguinte sintaxe

⬇
1def foo(x):
2  bloco

Aqui, foo é o nome da função, x é o parâmetro (variável) de entrada e bloco é o bloco de programação que a função executa ao ser chamada. Uma função pode ter mais parâmetros ou não ter parâmetro de entrada.

Exemplo 4.2.1.

O seguinte código, define a função areaCirc que computa e imprime a área de uma circunferência de raio r.

⬇
1import math as m
2
3def areaCirc(r):
4  area = m.pi * r**2
5  print(f'área = {area}')

Uma vez definida, a função pode ser chamada em qualquer parte do código. Por exemplo, vamos continuar o código de forma que a(o) usuária(o) informe os raios de duas circunferências e o código compute e imprima o valor das áreas de cada circunferência.

⬇
1import math as m
2
3# def fun
4def areaCirc(r):
5  area = m.pi * r**2
6  print(f'área = {area}')
7
8# entrada de dados
9raio1 = float(input('Digite o raio da 1. circ.:\n'))
10raio2 = float(input('Digite o raio da 2. circ.:\n'))
11
12print(f'Circunferência de raio = {raio1}')
13areaCirc(raio1)
14
15print(f'Circunferência de raio = {raio2}')
16areaCirc(raio2)
Observação 4.2.1.

(docstring.) Python recomenda a utilização do sistema de documentação docstring. Na definição de funções, um pequeno comentário sobre sua funcionalidade, seguido da descrição sobre seus parâmetros podem ser feito usando '''', logo abaixo da instrução def. Por exemplo,

⬇
1import math as m
2
3# def fun
4def areaCirc(r):
5  '''
6  Computa e imprime a área de uma
7  circunferência.
8
9  Entrada
10  -------
11  r : float
12  Raio da circunferência.
13  '''
14  area = m.pi * r**2
15  print(f'área = {area}')

Com isso, podemos usar a função help para obter a documentação da função areaCirc.

⬇
1>>> help(areaCirc)

Verifique!

Uma função pode ser definida sem parâmetro de entrada.

Exemplo 4.2.2.

O seguinte código, implementa uma função que imprime um número randômico par entre 0 e 100 (incluídos).

⬇
1import random
2
3def randPar100():
4  '''
5  Imprime um número randômico
6  par entre 0 e 100 (incluídos).
7  '''
8  n = random.randint(0, 99)
9  if (n % 2 == 0):
10    print(n)
11  else:
12    print(n+1)

Para chamá-la, usamos

⬇
1>>> randPar100()

Verifique!

4.2.1 Funções com Saída de Dados

Além de parâmetros de entrada, uma função pode ter saída de dados, i.e. pode retornar dados para o programa. Para isso, usamos a instrução return que interrompe a execução da função e retorna ao programa principal. Quando o return é seguido de um objeto, a função tem como saída o valor desse objeto.

Exemplo 4.2.3.

Vamos atualizar a versão de nosso código do Exemplo 4.2.1. Aqui, em vez de imprimir, a função areaCirc(r) tem como saída o valor computado da área da circunferência de raio r

⬇
1import math as m
2
3# def fun
4def areaCirc(r):
5    area = m.pi * r**2
6    return area
7
8# entrada de dados
9raio1 = float(input('Digite o raio da 1. circ.:\n'))
10raio2 = float(input('Digite o raio da 2. circ.:\n'))
11
12print(f'Circunferência de raio = {raio1}')
13area1 = areaCirc(raio1)
14print(f'\tárea = {area1}')
15
16print(f'Circunferência de raio = {raio2}')
17area2 = areaCirc(raio2)
18print(f'\tárea = {area2}')

Funções podem retornar objetos de qualquer classe de dados. Quando queremos retornar mais de um objeto por vez, usualmente usamos um tuple como variável de saída.

Exemplo 4.2.4.

O seguinte código, cria uma função para a computação das raízes de um polinômio de grau 2

p⁢(x)=a⁢x2+b⁢x+c. (4.3)
Código 2: raizes_v1.py
⬇
1import math as m
2
3def raizes(a, b, c):
4  '''
5  Computa as raízes de
6  p(x) = ax^2 + bx + c
7
8  Entrada
9  -------
10  a : float
11  Coeficiente do termo quadrático.
12  Atenção! Deve ser diferente de zero.
13
14  b : float
15  Coeficiente do termo linear.
16
17  c: float
18  Coeficiente do termo constante.
19
20  Saída
21  -----
22  x1 : float
23  Uma raiz do polinômio.
24
25  x2 : float
26  Outra raiz do polinômio.
27  Atenção! No caso de raiz dupla,
28  x1 == x2.
29  '''
30
31  # auxiliares
32  _2a = 2*a
33  _b2a = -b/_2a
34
35  # discriminante
36  delta = b**2 - 4*a*c
37
38  # raízes
39  if (delta > 0):
40    x1 = _b2a + m.sqrt(delta)/_2a
41    x2 = _b2a - m.sqrt(delta)/_2a
42    return x1, x2
43  elif (delta < 0):
44    img = m.sqrt(-delta)/_2a
45    x1 = _b2a + img*1j
46    return x1, x1.conjugate()
47  else:
48    return _b2a, _b2a

Verifique!

4.2.2 Capturando Exceções

Exceções são classes de erros encontrados durante a execução de um código. Ao encontrar uma exceção, a execução do código Python é imediatamente interrompida e uma mensagem é impressa indicando a classe do erro e a linha do código em ocorreu. Por exemplo, ao chamarmos raizes(0, 1, 2) definida no Código 2, obtemos uma exceção da classe ZeroDivisionError.

⬇
1>>> raizes(0,1,2)
2Traceback (most recent call last):
3  File "<stdin>", line 1, in <module>
4  File "/AlgoritmosProgramacaoI/aux.py", line 33, in raizes
5    _b2a = -b/_2a
6ZeroDivisionError: division by zero

Podemos controlar as exceções com a instrução try-except. Sua sintaxe é

⬇
1try:
2  comando1
3except:
4  comando2

Ou seja, o código tenta executar o comando1, caso ele gere uma exceção, o comando2 é executado. A lista de exceções predefinidas na linguagem pode ser consultada em

https://docs.python.org/3/library/exceptions.html

Exemplo 4.2.5.

No Código 2, podemos evitar e avisar a(o) usuária(o) da divisão por zero no caso de a=0.

Código 3: raizes_v2.py
⬇
1import math as m
2
3def raizes(a, b, c):
4  '''
5  Computa as raízes de
6  p(x) = ax^2 + bx + c
7
8  Entrada
9  -------
10  a : float
11  Coeficiente do termo quadrático.
12  Atenção! Deve ser diferente de zero.
13
14  b : float
15  Coeficiente do termo linear.
16
17  c: float
18  Coeficiente do termo constante.
19
20  Saída
21  -----
22  x1 : float
23  Uma raiz do polinômio.
24
25  x2 : float
26  Outra raiz do polinômio.
27  Atenção! No caso de raiz dupla,
28  x1 == x2.
29  '''
30
31  # auxiliares
32  _2a = 2*a
33
34  try:
35    _b2a = -b/_2a
36  except ZeroDivisionError:
37    raise ZeroDivisionError('a deve ser != 0.')
38
39  # discriminante
40  delta = b**2 - 4*a*c
41
42  # raízes
43  if (delta > 0):
44    x1 = _b2a + m.sqrt(delta)/_2a
45    x2 = _b2a - m.sqrt(delta)/_2a
46    return x1, x2
47  elif (delta < 0):
48    img = m.sqrt(-delta)/_2a
49    x1 = _b2a + img*1j
50    return x1, x1.conjugate()
51  else:
52    return _b2a, _b2a
Observação 4.2.2.

Nos casos gerais, pode-se utilizar a seguinte sintaxe:

⬇
1try:
2  comando1
3except:
4  raise Exception('msg')

4.2.3 Criando um Módulo

Para criar um módulo em Python, basta escrever um código foo.py com as funções e constantes que quisermos. Depois, podemos importá-lo em outro código com a instrução import.

Exemplo 4.2.6.

Considere um retângulo de lados a e b. Na sequência, temos um módulo com algumas funções.

Código 4: retangulo.py
⬇
1'''
2Módulo com funcionalidades sobre
3retângulos.
4'''
5
6import math as m
7
8def perimetro(a, b):
9  '''
10  Perímetro de um retângulo de
11  lados a e b.
12
13  Entrada
14  -------
15  a : float
16  Comprimento de um dos lados.
17
18  b : float
19  Comprimento de outro dos lados.
20
21  Saída
22  -----
23  p : float
24  Perímetro do retângulo.
25  '''
26
27  p = 2*a + 2*b
28  return p
29
30def area(a, b):
31  '''
32  Área de um retângulo de
33  lados a e b.
34
35  Entrada
36  -------
37  a : float
38  Comprimento de um dos lados.
39
40  b : float
41  Comprimento de outro dos lados.
42
43  Saída
44  -----
45  area : float
46  Área do retângulo.
47  '''
48
49  area = a*b
50  return area
51
52def diagonal(a, b):
53  '''
54  Comprimento da diagonal de
55  um retângulo de lados a e b.
56
57  Entrada
58  -------
59  a : float
60  Comprimento de um dos lados.
61
62  b : float
63  Comprimento de outro dos lados.
64
65  Saída
66  -----
67  diag : float
68  Diagonal do retângulo.
69  '''
70
71  diag = m.sqrt(a**2 + b**2)
72  return diag

Agora, usamos nosso módulo perimetro.py em um outro código que fornece informações sobre o retângulo de lados a e b informados por usuária(o).

⬇
1import retangulo as rect
2
3a = float(input('Lado a: '))
4b = float(input('Lado b: '))
5
6diag = rect.diagonal(a, b)
7print(f'diagonal = {diag}')
8
9perim = rect.perimetro(a, b)
10print(f'perímetro = {perim}')
11
12area = rect.area(a, b)
13print(f'área = {area}')

4.2.4 Exercícios

E. 4.2.1.

Defina uma função que recebe os catetos a e b de um triângulo retângulo e retorne o valor de sua hipotenusa. Use-a para escrever um código em que a(o) usuária(o) informa os catetos e obtenha o valor da hipotenusa.

E. 4.2.2.

Defina uma função que recebe os lados a, b e c de um triângulo qualquer e retorne o valor de sua área. Use-a para escrever um código em que a(o) usuária(o) informa os lados do triângulo e obtenha o valor da área.

Resposta.

Dica: Use o Teorema de Heron.

E. 4.2.3.

Defina uma função que retorna um número randômico ímpar entre 1 e 51 (incluídos). Use-a para escrever um código em que:

  1. 1.

    A(o) usuária(o) informa um número inteiro n≥1.

  2. 2.

    Cria-se uma lista de n números randômicos ímpares entre 1 e 51 (incluídos).

  3. 3.

    Computa-se e imprime-se a média dos n números.

Resposta.
⬇
1import random
2
3def randImpar(m=51):
4  '''
5  Retorna um número randômico
6  ímpar entre 1 e m (incluídos).
7
8  Entrada
9  -------
10  m : int
11  Maior inteiro ímpar que pode ser
12  gerado. Padrão: m = 51.
13
14  Saída
15  -----
16  n : int
17  Número randômico ímpar.
18  '''
19  n = random.randint(0, m-1)
20  if (n % 2 != 0):
21    return n
22  else:
23    return n+1
24
25# entrada de dados
26n = int(input('Digite o tamanho da lista:\n'))
27
28# gera a lista
29lista = [0]*n
30for i in range(n):
31  lista[i] = randImpar()
32
33# calcula a média
34soma = sum(lista)
35media = soma/len(lista)
36
37# imprime o resultados
38print(f'média = {media}')
E. 4.2.4.

Desenvolva um código para computar a raiz de uma função afim

f⁢(x)=a⁢x+b, (4.4)

com coeficientes a e b informados por usuária(o). Use instruções try-except para monitorar as exceções em que a usuária informe números inválidos ou a=0.

Resposta.
⬇
1import math as m
2
3def raizFunAfim(a, b):
4  '''
5  Computa a raiz de
6  f(x) = ax + b
7
8  Entrada
9  -------
10  a : float
11  Coeficiente angular.
12
13  b : float
14  Coeficiente linear.
15
16  Saída
17  -----
18  x : float
19  Raiz de f(x).
20  '''
21
22  try:
23    x = -b/a
24  except ZeroDivisionError:
25    raise ZeroDivisionError('coef. angular deve ser != 0.')
26
27  return x
28
29# entrada de dados
30try:
31  a = float(input('Coef. angular: '))
32except ValueError:
33  raise ValueError('Número inválido.')
34
35try:
36  b = float(input('Coef. linear: '))
37except ValueError:
38  raise ValueError('Número inválido.')
39
40# raiz
41raiz = raizFunAfim(a, b)
42
43# imprime
44print(f'raiz = {raiz}')
E. 4.2.5.

Considere polinômios de segundo grau

p⁢(x)=a⁢x2+b⁢x+c. (4.5)

Desenvolva um módulo com as seguintes funções:

  1. a)

    intercepta_y(): função que retorna o ponto de interseção do gráfico de y=p⁢(x) com o eixo das ordenadas3434endnote: 34Eixo y..

  2. b)

    raizes(): função que retorna as raízes de p.

  3. c)

    vertice(): função que retorna o vértice do gráfico de y=p⁢(x).

Então, use seu módulo em um código em que a(o) usuária(o) informa os coeficientes a, b e c e obtém informações sobre as raízes, o ponto de interseção com o eixo y e o vértice de p.

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!

| | | |