Exibir código-fonte para Funções

= Funções =
<br>


[[Arquivo:Funcoes.jpg|center]]



== Importância das funções em um programa ==
<br>

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.


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'''.


== Definindo funções no Python! ==
<br>


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 abaixo. 

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'''.


 >>> def soma(x,y):
 ...   return x + y
 ... 
 >>> def diferenca(x,y):
 ...   return x - y
 ... 
 >>> def produto(x,y):
 ...   return x * y
 ... 
 >>> def divisao(x,y):
 ...   return x/y
 ... 
 

Se executarmos estas funções no prompt:


 >>> 
 >>> soma(10,13)
 23
 >>> diferenca(10,13)
 -3
 >>> produto(10,13)
 130
 >>> divisao(10,13)
 0
 >>> 



* 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.


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


* Função produto
** São passados obrigatoriamente dois parâmetros e é retornada a multiplicação dos dois valores
** Esta função pode receber quaisquer objetos que suportem a operação de soma e pode retornar valor muito alto


* Função divisao
** São passados obrigatoriamente dois parâmetros e é retornada o quociente dos dois valores
** Quando o dividendo é menor que o divisor e os dois valores são inteiros retorna apenas o quociente inteiro
** Deve existir uma regra para a divisão por sero
<br>

Algumas variações possíveis:

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

Algumas variaçõ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


 >>> produto("bola","3")
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in produto
 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
 >>> 
<br>

== Chamando funções dentro do seu programa ==
<br>

 #chamando funções
 >>> def expoente2(x):
 ...   return produto(x,x)
 ... 
 >>> 
 >>> expoente2(4)
 16
 >>> expoente2(12)
 144
 >>> expoente2(25)
 625
 >>> 
<br>


Existem algumas características interessantes da passagem de parâmetros em Python. Veremos algumas a seguir.
<br>

== Parâmetros com valor padrão ==
<br>

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:


 #parâmetros com valores padrão
 >>> def brasileiro(resposta="sim"):
 ...   if resposta == "sim":
 ...      print "brasileiro"
 ... 
 
Neste caso se chamássemos esta função no shell do python, ficaria assim:

 >>> brasileiro()
 brasileiro
 >>> brasileiro("sim")
 brasileiro
 >>> brasileiro("s")
 >>> 
<br>

Assim, se o parâmetro com valor padrão for omitido, o valor padrão será usado.


* Repare que existe na função brasileiro()  existe um comando if que permite implementar a condição no programa. 
** Se for verdade a condição, faça isso => print "brasileiro"
** Se não, não fará nada.
* Trataremos desse comando com mais detalhes a  frente porque ele será extensamente usado.

Exemplos:

 >>> 
 >>> def gosto():
 ...   return "Humm"
 ... 
 >>> gosto
 <function gosto at 0x7fb77b107b18>   #Descubra o motivo do erro
 >>> gosto()
 'Humm'
 <br>


Um caso particular desta propriedade da passagem de parâmetros das funções é a utilização de vários argumentos com valores padrão. São funções com argumentos chave.


As chamadas a esta função podem ocorrer da seguinte maneira:

Caso normal:
 >>> 
 >>> def gosto(acao='comer'):
 ...   print "Eu gosto de chuchu"
 ... 
 >>> gosto()
 Eu gosto de chuchu
<br>

Com parâmteros:


 >>> 
 >>> def gosto(acao='comer',objeto1='batata frita',objeto2='bife'):
 ...   print "Eu gosto de ",acao," ",objeto1," com ",objeto2
 ... 
 >>> gosto()
 Eu gosto de  comer   batata frita  com  bife
 >>> 
 >>> gosto(acao='comprar')
 Eu gosto de  comprar   batata frita  com  bife
 >>> 
 >>> gosto(objeto1='frango',objeto2='farofa')
 Eu gosto de  comer   frango  com  farofa
 >>> 
 >>> gosto(objeto1='frango',objeto2='farofa',acao='provar')
 Eu gosto de  provar   frango  com  farofa
 >>> 
<br>

Os parâmetros passados vão para o argumento ao qual são atribuídos. 


Com estas informações, você já será capaz de começar a fazer suas próprias funções! 

Lembre-se que se a função não retorna nada o return pode ser omitido.