Funções

Kethllen Andrey Santos

UFU

2016

Informática para Biotecnologia

Funções são trechos de código que possuem nome e argumentos (algumas funções não possuem argumentos) e podem ser invocados em outras partes do programa

É comum se dizer que uma função ‘recebe’ um ou mais valores e ‘retorna’ um resultado.
Este resultado é chamado de valor de retorno

Algumas funções já estão disponíveis no interpretador, por exemplo, a usada no cálculo do seno de um ângulo que está presente na biblioteca math.sin do Python.

O que são funções?

Quando escrevemos o trecho de um programa, eventualmente precisamos executá-lo várias vezes
À medida que evoluímos na programação pode ser necessário que o utilizemos em outros programas
É o que está acontecendo neste momento, os códigos começam a ficar maiores e tendem a aumentar cada vez mais
Se separarmos partes de um programa em trechos claros, simples e objetivos pode ser que consigamos um código menor, mais legível e mais organizado
Esta subdivisão de um programa mais complexo em partes menores é chamada modularização.

Importância das funções

Usaremos nesse caso, a palavra reservada def, que indica a definição de uma função
Em seguida, especificamos o nome da função e os nomes dos parâmetros de entrada
Estes parâmetros podem assumir várias formas como pode ser visto a frente
Eles nunca são usados para retornar dados para o programa principal ou para a função que a chama
Que fique claro que a única forma de retornar dados no Python é através da instrução return.

Definindo funções no Python

>>> def soma(x,y):
...   return x + y
...

Funções

Função soma
- São passados obrigatoriamente dois parâmetros e é retornada a soma dos dois
- Esta função pode receber quaisquer objetos que suportem a operação de soma.

>>> def subtracao(x,y):
...   return x - y
...

Funções

Função diferenca
- São passados obrigatoriamente dois parâmetros e é retornada a subtração dos dois
- Pode receber quaisquer objetos que suportem a operação e pode retornar valor negativo

>>> def multiplicacao(x,y):
...   return x * y
...

Funções

Função produto
- São passados obrigatoriamente dois parâmetros e é retornada a multiplicação dos dois
- Pode receber quaisquer objetos que suportem a operação e pode retornar valor muito alto

>>> def divisao(x,y):
...   return x / y
...

Funções

Função Quociente
- São passados obrigatoriamente dois parâmetros e é retornada o quociente dos dois valores
- Para dividendo menor que o divisor e 2 valores inteiros retorna apenas o quociente inteiro
- Obrigatoriamente o divisor deve ser diferente de zero.

Funções

Executando funções

>>> soma(2,2)
4
>>> subtracao(2,2)
0
>>> multiplicacao(2,2)
4
>>> divisao(2,2)
1
>>>

Algumas variações possíveis

>>> soma("casa","nova")
'casanova'
>>> subtracao(10.0,13.0)
-3.0
>>> multiplicacao("Ha",3)
'HaHaHa'
>>> divisao(20.0,2)
10.0

Algumas funções inadequadas

>>> soma("nro",23)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in soma
TypeError: cannot concatenate 'str' and 'int' objects
>>> 
KeyboardInterrupt

>>> multiplicacao("bola","3")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in multiplicacao
TypeError: can't multiply sequence by non-int of type 'str'

>>> divisao(2,0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in divisao
ZeroDivisionError: integer division or modulo by zero

Chamando funções dentro de programas

É possível invocar funções de outras funções

>>> def produto(x,y):
...   return x * y
... 
>>> def potencia(x):
...   return produto(x,x)
... 
>>> potencia(2)
4
>>> potencia(3)
9
>>> potencia(4)
16
>>> potencia(5)
25
>>> potencia(-2)
4
>>> potencia(2.5)
6.25
>>>

Parâmetros com valor padrão

>>> def imprime_texto(resposta="sim"):
...   print(resposta)
... 
>>> imprime_texto() # Neste caso, sem argumentos
sim
>>> imprime_texto("Não") # Neste caso, comm argumentos
Não
>>>

Funções com parâmetros com valor padrão podem receber um número variável de parâmetros na chamada, pois o valor padrão será assumido para o parâmetro omitido
Sempre deixamos o parâmetro com valor padrão para o final da tupla na definição da função
Observe:

Funções sem argumento

>>> def gosto():
...   print("Huummmm")
... 
>>> 
>>> gosto
<function gosto at 0x7f73179d2938>
>>> gosto()
Huummmm
>>> gosto("Arghhh")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: gosto() takes no arguments (1 given)
>>>

Deve ficar bem claro, o padrão de chamada da função

Repare que na primeira chamada não está caracterizada a chamada de uma função
Na segunda, sim, invocação sem argumento
Na terceira, invocação com argumento sendo que na função original não existe argumento.

Funções vários argumentos

>>> def variosargs(a,b,c,d,e,f,g):
....   return(a+b+c+d+eF=g)
>>> 
>>> variosarg(1,1,1,1,1,1,1)
7

É possível termos vários argumentos:

Os parâmetros são enviados à função e processados de acordo com sua denominação

Exercícios

Criar as seguintes funções:

Potencia: Retorna o potência de um determinado número
Repete: Mostra uma palavra repetida n vezes
Equacao1: Determina o valor de m na equação (m-5)x=2016
Delta: Retorna o delta da fórmula de Baskhara
Juro: Mostra um valor acrescido da taxa de juros
Cubica: Retorna um valor elevado à 3a. potência
Eq2: Imprime a expressão: "O valor da equação x = 2y - 3z / 5w é igual a " resultado.
Eq3: Retorna o valor da equação a = bcd/e+4
Eq4: Retorna o valor da equação z = x+2 / |y -4|
Temperatura: Crie um aplicativo de conversão entre as temperaturas Celsius e Fahrenheit.
Aproveitando a função do exercício 4, desenvolva um programa que receba os coeficientes a, b e c e calcule as raízes de uma equação de segundo grau.

“É divertido fazer o impossível, pois lá a concorrência é menor.”

Walt Disney

Exercícios

>>> def potencia(x,y):
...   return pow(x,y)
... 
>>> potencia(2,3)
8
>>> potencia(3,3)
27
>>> potencia(2,-3)
0.125
>>>

>>> def repete(x,y):
...   print(x*y)
... 
>>> repete("Ha",3)
HaHaHa
>>> repete("K",5)
KKKKK
>>> repete("zzz",10)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
>>>

>>> def equacao1(x):
...   print((2016/x)+5)
... 
>>> equacao1(2)
1013
>>> equacao1(4)
509
>>> equacao1(-5)
-399

>>> def delta(a,b,c):
...   print(b*b - 4*a*c)
... 
>>> delta(2,2,2)
-12
>>> delta(2,1,1)
-7
>>> 
>>> delta(-3,1,1)
13
>>> delta(-3,-2,1)
16

>>> def juro(p,t):
...   print(p+p*t/100)
... 
>>> juro(100,20)
120
>>> juro(80,10)
88
>>> juro(100,-10)
90
>>> juro(80,-10)
72

>>> def cubica(x):
...   return(pow(x,3))
... 
>>> cubica(2)
8
>>> cubica(4)
64
>>> cubica(-2)
-8

>>> def eq2(y,z,w):
...    return((2*y-3*z)/5*w)
... 
>>> y = 2
>>> w = 2
>>> z = 2
>>> print("O resultado da equacao de %d, %d e %d é %d" %(y,z,w,eq2(y,z,w)))
O resultado da equacao de 2, 2 e 2 é -2

>>> def eq3(b,c,d,e):
...   return(b*c*d/(e+4))
... 
>>> eq3(2,2,2,2)
1
>>> eq3(2.0,2.0,2.0,2.0)
1.3333333333333333
>>> eq3(2.0,2.0,2.0,2)
1.3333333333333333
>>> eq3(2.0,2.0,2,2)
1.3333333333333333
>>> eq3(2.0,2,2,2)
1.3333333333333333
>>>

>>> def eq4(x,y):
...   return(x+2)/(abs(y-4))
... 
>>> eq4(2,2)
2
>>> eq4(2,0)
1
>>> eq4(2,-2)
0
>>> eq4(2,-4)
0
>>> eq4(2,4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in eq4
ZeroDivisionError: integer division or modulo by zero

Exercícios

>>> temp = int(raw_input("Digite o valor em graus Celsius: "))
Digite o valor em graus Celsius: 37
>>> print("A Temperatura em graus Fahrenheit é: %d" %(temp+273))
A Temperatura em graus Fahrenheit é: 310
>>> 
>>> temp = float(raw_input("Digite o valor em graus Celsius: "))
Digite o valor em graus Celsius: 37
>>> print("A Temperatura em graus Fahrenheit é: %f" %(temp+273))
A Temperatura em graus Fahrenheit é: 310.000000
>>>

>>> def delta(a,b,c):
...   return(b*b - 4*a*c)
... 
>>> a = int(raw_input("Digite o valor de a: "))
Digite o valor de a: 2
>>> b = int(raw_input("Digite o valor de b: "))
Digite o valor de b: 2
>>> c = int(raw_input("Digite o valor de c: "))
Digite o valor de c: 2
>>> x1 = -b+pow(abs(delta(a,b,c)),0.5)
>>> x2 = -b-pow(abs(delta(a,b,c)),0.5)
>>> print("As raízes da equação são: %f e  %f" %(x1,x2)) 
As raízes da equação são: 1.464102 e  -5.464102
>>>
>>> a = int(raw_input("Digite o valor de a: "))
Digite o valor de a: 1
>>> b = int(raw_input("Digite o valor de b: "))
Digite o valor de b: 2
>>> c = int(raw_input("Digite o valor de c: "))
Digite o valor de c: 1
>>> x1 = -b+pow(abs(delta(a,b,c)),0.5)
>>> x2 = -b-pow(abs(delta(a,b,c)),0.5)
>>> print("As raízes da equação são: %f e  %f" %(x1,x2)) 
As raízes da equação são: -2.000000 e  -2.000000