[INF1025] Resumo Função

Prévia do material em texto

INF1025: Introdução à Programação 
Monitor: André Vicente Pessanha 
Resumo Função: 
 
*************************************************************************************************** 
 
OBS:​ Essa matéria "Só" é cobrada na P1, P2 e P3! :D 
 
*************************************************************************************************** 
 
- Descrição: 
 
Função é como se fosse uma máquina ou um robô que é criado pra executar alguma ação 
específica. Cada função possui um protótipo que contém informações como seu nome e o 
que recebe como parâmetro. 
 
- Vantagens de usar função: 
 
Deixa o programa mais organizado. Pois ao invés de fazer um programa inteiro de uma só 
vez, separar em "bloquinhos" de funções ajuda bastante na visualização do programa e 
facilita pra modificações futuras, pois deixa o código o mais genérico possível. 
 
E além disso, é uma forma de evitar repetição de código. Pois é só chamar a função 
quantas vezes precisar executar uma determinada ação. 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Como Definir/Criar uma função? 
 
 
Primeiro precisamos definir a função usando >> ​def​ << e logo em seguida o nome da 
função e seus parâmetros. 
 
EX: ​Uma função que calcula e retorna a soma entre dois valores. 
 
def calculaSoma ( valor, valor2): 
 return valor + valor2 
 
 
OBS:​ >>SEMPRE<< use nomes que facilitem identificar o que a função faz! Por exemplo, 
uma função que só exibe algum resultado na tela, use um desses nomes aqui ou algum 
parecido: exibe, imprime, mostra, exibeResultado, mostraResultado, etc. 
 
OBS2:​ Assim como em repetição e condições >> Sempre << temos que colocar os dois 
pontos >> ​: ​<< Lembrando que na maioria das linguagens é usado chaves ​{ }​ pra delimitar 
o corpo da função, mas como em Python esse critério é feito baseado na identação do 
código e só temos os dois pontos pra indicar o começo do bloco da função. Temos que ter 
um cuidado triplicado com a identação do código! (Waaait! Não lembra o que é identação? 
É só dar uma lida no tópico >> Organização e Identação do código << no PDF “Dicas 
Gerais” :) 
 
 
OBS:​ Nomes de variáveis e de funções nunca levam espaço! Então se for um nome 
composto, coloque a primeira letra da segunda palavra em >> Maiúsculo << como no 
exemplo acima ou coloque um underline entre as palavras! def calcula_soma (valor, valor2): 
 
Regra Importante:​ >> NUNCA << use nomes iguais pra funções e variáveis!!! 
 
Imagine que vc declarou uma variável chamada soma e criou uma função que também se 
chama soma. Como o programa vai saber diferenciar qual é qual? :D 
Cuidado! Esse é o erro mais comum de todos na P1! :( 
 
def calculaSoma (valor, valor2): 
 
E a última parte, após o nome da função, é a lista de parâmetros que a função recebe que 
ficam sempre entre parênteses! Lembrando que essa quantidade do exemplo não é uma 
regra, uma função pode ter 5 parâmetros enquanto outra pode não receber nenhum, isso 
vai depender do enunciado da questão. 
 
OBS:​ Se uma função não recebe parâmetros é só deixar os parênteses em branco! 
 
def exibeResultado( ): 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Como se chama uma função? 
 
Da mesma forma como você chamaria uma pessoa, sempre pelo nome! :) 
 
def calculaSoma(valor, valor2): 
 return valor + valor2 
 
soma = calculaSoma(5, 10) 
print("Resultado da soma: ", soma) 
 
Como sabemos que a função calculaSoma retorna um inteiro, antes de chamar ela 
declaramos uma variável pra armazenar/salvar o que a função retorna. 
 
OBS: ​Lembrando que o sinal de atribuição para armazenar algo: >> ​ =​ << 
E esse é o sinal para verificar igualdade: ​ ​>> ​==​ << 
Já que a função vai retornar obrigatoriamente um inteiro e vamos precisar usar esse 
resultado depois, precisamos armazenar o valor retornado em alguma variável. 
 
Mas ao invés disso, como só vamos exibir o resultado na tela, podemos usar um atalho e 
imprimir direto o resultado! (Sem declarar a variável soma) 
 
print("Resultado da soma: ", ​calculaSoma(5, 10)​) 
 
É só chamar a função calculaSoma dentro do print, com isso, o valor retornado pela função 
vai ser automaticamente exibido na tela! 
 
OBS:​ Lembrando que isso é só um atalho, as duas formas estão 100% corretas. Mas 
quanto menos vc precisar escrever na prova melhor! :) 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Função que não retorna nada: 
 
def exibeMensagem ( ): 
print("Isso é uma mensagem!\n") 
 
exibeMensagem() #Chamando a função! 
 
 
OBS:​ Se os parênteses estiverem vazios quer dizer que a função >>​ NÃO​ << recebe 
nenhum parâmetro! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
-​ Duas formas de resolver o mesmo problema: 
 
EX:​ Faça uma função que recebe duas notas e seus respectivos pesos e retorne a média 
ponderada: 
 
Caminho mais longo: 
 
def calculaMedia(nota, nota2, peso, peso2): 
 media = (nota * peso + nota2 * peso2) / (peso + peso2) 
 return media 
 
print(calculaMedia(8.5, 5.0, 1, 2)) 
 
 
OBS:​ Nesse caso é obrigatório o uso dos parênteses em (peso + peso2) pra deixar claro a 
ordem da precedência! Pois primeiro precisamos somar os pesos antes de dividir! (Assim 
como é feito em cálculo) 
 
 Caminho mais curto: (Atalho) 
 
def calculaMedia(nota, nota2, peso, peso2): 
 return (nota * peso + nota2 * peso2)/(peso + peso2) 
 
 
OBS:​ Não existe caminho mais certo que o outro, ambos estão corretos! Mas como existe o 
problema do tempo nessas provas, o ideal é você tentar ao máximo reduzir as etapas com 
esses atalhos pra não perder tanto tempo. 
 
OBS2:​ Em >>TODA<< P1 cai uma questão com um item pedindo pra fazer uma função que 
é algo tão simples que você pode simplesmente usar esse atalho e resolver tudo numa 
única linha. :) 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Limitar a quantidade de casas decimais: 
 
Teste o exemplo acima no IDLE, notou que ele sempre exibe o resultado da média com ​6 
casas decimais? :O 
 
Isso acontece porque é justamente a quantidade padrão de casas decimais. Mas não fica 
muito bom visualmente, por isso o ideal é sempre limitar essa quantidade para no >> 
Máximo 2 << casas decimais! (Ou a quantidade que o enunciado especificar) 
 
print("Média: ​%.2f​\n" % calculaMedia(8.5, 5.0, 1, 2)) 
 
OBS:​ Como o formato de impressão ​%f ​é compatível com valores que possuem casas 
decimais (Tipo Float) Então é só colocar >>​ %.2f ​<< para limitar a quantidade de casas para 
>> 2 <<! Não se esqueça de colocar aquele >> Ponto << após o símbolo de %! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Passagem de parâmetro por valor e variáveis locais: 
 
 
Sempre que criamos uma variável e a enviamos como parâmetro para uma função, na 
verdade >>NÃO<< estamos enviando a variável para a função, o que acontece é 
simplesmente uma cópia do seu valor! :O 
 
 
def modifica(x): 
 x += 2 
 print(x) #Exibe 7 na tela (Pois nessa função x vale 7!) 
 
x = 5 
modifica(x) 
print(x) #Exibe 5 na tela (Pois aqui x vale 5!) 
 
 
Vamos por partes: Temos a função modifica que soma + 2 e atualiza o valor de x recebido 
como parâmetro e o exibe na tela. (​Aqui x​ é uma >>​ Variável Local​ << ​da função!​ Ou 
seja, tanto a variável x quanto essa alteração que foi feita só >> Existe << dentro da função 
modifica!) 
 
E fora da função, declaramos uma variável chamada x e inicializamoscom o valor 5 (​Aqui x 
é uma >> ​Variável Global​ << pois ela está fora de qualquer função! ) 
 
Waaaait! Então quer dizer que a variável x dentro da função e a variável x fora da função 
são diferentes!?!? 
Sim! :O 
 
modifica(x) #Chamada da função modifica 
 
Assim que chamamos a função modifica passando x como parâmetro, o sistema faz uma 
>>CÓPIA<< do valor 5 e logo em seguida >>COLA<< esse valor no parâmetro da função 
modifica. Sim, é basicamente um "copia e cola"! :O 
 
def modifica(x): 
 
Nessa parte é "colado" o valor 5 em x. Lembrando que x é uma variável local da função 
modifica! (Essa variável >> Só << é visível dentro da função modifica!) 
 
 
OBS:​ Lembra que não podemos usar nomes iguais pra funções e variáveis? 
 
Na verdade isso só vale pra variáveis locais que pertencem a >>MESMA<< função! (Assim 
como variáveis Globais) E como se tratam de variáveis diferentes, podemos usar nomes 
iguais, apesar do recomendado ser usar nomes diferentes. Por um lado, usar nomes iguais 
pode facilitar na hora de lembrar qual foi a variável que estamos “enviando”. Como se a 
gente tivesse enviando a mesma variável como parâmetro, mas é muito importante 
entender que não é assim que funciona, na verdade é uma cópia de valores e são variáveis 
diferentes! 
 
Dessa forma: (Usando nomes Diferentes) 
 
def modifica(x): 
 x += 2 
 print(x) 
 
valor = 5 
modifica(valor) 
print(valor) 
 
 
OBS:​ Não está seguro de quando usar nomes iguais ou diferentes? Ouviu falar de um 
negócio chamado variável local, mas nem sabe do que se trata? :D 
 
Sem problemas! É só usar nomes diferentes em todos os casos! :) 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Funções úteis da Linguagem: 
 
1) ​A função​ str() ​converte um número (Int ou float) para o tipo string. 
 
x = 10 
str(10) 
 
2) ​A função ​int()​ e ​float() ​convertem string para número. 
 
taxa = 50.5 
custo = float(input(“Digite o custo total:\n”)) 
custo = custo + taxa 
 
OBS:​ O valor lido pela função input é >> Sempre << do tipo string. Se caso precisar fazer 
contas com a variável, precisamos converter para número antes! (Recomendo converter 
sempre para float) 
 
3)​ A função ​len()​ retorna a quantidade de caracteres que uma string possui. 
 
print( len (“Teste”) ) #Quantidade de caracteres: 5 
 
OBS: ​E além disso, retorna a quantidade de elementos de uma lista (Matéria da P2) 
 
4)​ A função ​abs​ retorna o módulo (Valor absoluto) de um número. 
 
abs( -10) #Retorna 10 
 
6) ​A função ​cmp(x,y) ​recebe 2 parâmetros, faz uma comparação e retorna: 
 
Um valor positivo se x > y ​OU​ Um valor negativo se x < y ​OU​ Zero se x == y 
 
7) ​A função​ type​ retorna o tipo de uma variável. 
 
x = 7.5 
type(x) #O tipo da variável x é float 
 
8)​ A função ​id​ retorna a identificação da variável na memória: 
 
x = 7.5 
soma = 7.5 
print(id(x)) #Exibe o id 49282976 
print(id(soma)) #Exibe o id 49282976 
 
OBS: ​Um detalhe importante pra se notar é que a identificação é em relação ao valor 
(Conteúdo) e não a variável! (Em C é exatamente o contrário) 
E o id só é criado na memória, a partir do momento que inicializamos uma variável com um 
valor! Por isso no exemplo acima ambos print exibem o mesmo código de id, pois ambas 
variáveis x e soma estão associadas ao valor 7.5! 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Funções úteis de Módulos Externos: 
 
OBS: ​Para usar qualquer uma das funções citadas abaixo, primeiro passo é >> Importar << 
o Módulo da função que vc quer usar através do comando >> ​import​ << seguido do nome 
do módulo externo. (Sempre no começo do programa!) 
 
OBS2:​ Toda função que pertence à um módulo ou a um tipo (String, int, etc) é chamado de 
>> ​Método​ << (Não é errado continuar chamando de função, mas é importante saber disso, 
pois podem usar ambos no enunciado das provas!) 
 
 
1) Funções de Cálculo: (import math) 
 
import math #Sempre coloque no >> Começo << do programa! 
 
print( math.radians(60) ) # Exibe o 60 em radianos 
 
OBS:​ A função radians >> só existe << dentro do Módulo math! Por isso precisamos 
sempre citar >>​ math.radians​ << o nome do módulo seguido do nome da função. Em 
vários exercícios pode ser útil usar as constantes math.​pi​ e math.​e 
 
 
2) Funções que geram números aleatórios: (import random) 
 
 
Gerar um número aleatório do tipo float num determinado intervalo (Inclui extremos) 
 
num = random.uniform(2, 5) 
 
Gerar um número aleatório do tipo inteiro num determinado intervalo. (Inclui 
extremos) 
 
num = random.randint(1,6) 
 
Escolhe um elemento aleatório dentro de um conjunto: 
 
alfabeto = "abcdefghijlmnopqrstuvwxyz" 
print(random.choice(alfabeto)) 
 
OBS:​ Lembrando que string é na verdade um conjunto de caracteres. 
 
OBS:​ As funções mais usadas são:​ uniform e randint​. (As únicas que incluem os extremos 
do intervalo) 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
- Documentação de funções criadas: (DOC STRING) 
 
A função ​help​ exibe a documentação de funções, será que isso tb vale pra funções que 
criamos? Será que podemos criar uma descrição para a funcionalidade de cada função 
criada? :O 
 
Sim! Imagine que temos um módulo chamado ​teste.py ​e colocamos uma função chamada 
calcArea​. Agora é só colocar na primeira linha de código da função a sua descrição! 
 
Conteúdo do módulo teste1.py: 
 
def calcAreaRet(b, h): 
 ​ """​Calcula a área de um retângulo.​""" 
 return b* h 
 
OBS:​ O nome desse comentário é >> ​Doc String​ << e só vai funcionar se for colocado 
exatamente no começo da função e usando as 3 aspas (Comentário com várias linhas) 
independente da descrição só possuir uma única linha. 
 
Agora vamos criar um novo módulo chamado​ teste2.py​ (Use sempre o atalho ​Ctrl + N​) O 
primeiro passo é importar o módulo que criamos (Exatamente da mesma forma como 
fizemos anteriormente com os módulos externos!) 
 
import teste 
 
print(help(teste.calcAreaRet)) 
 
Agora a nossa descrição será exibida na tela! :) 
 
OBS:​ Isso pode parecer algo completamente inútil, pois se nós criamos a função, óbvio que 
sabemos o que ela faz, então pra quê esse negócio de Doc String? D: 
 
Imagine que estamos trabalhando num grupo de programadores e cada um faz um conjunto 
de funções (Cada uma com um nome mais louco que o outro, cheio de abreviações Haha ) 
É nesse caso que o uso de Doc String nas funções faz muita diferença! 
 
Observe a ênfase que será dada durante as aulas, só perca tempo colocando se for 
realmente cobrado pois o foco dessa nova disciplina é justamente em fazer funções e 
testar. Antigamente na linguagem C era cobrado um programa colossal com 300 funções, 
então você já pode começar a comemorar agora. :D 
 
 
------------------------------------------------------- // ------------------------------------------------------------