Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
***************************************************************************************************
***************************************************************************************************
- 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.
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.
------------------------------------------------------- // ------------------------------------------------------------
EX: Uma função que calcula e retorna a soma entre dois valores.
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! :(
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.
def exibeResultado( ):
------------------------------------------------------- // ------------------------------------------------------------
Da mesma forma como você chamaria uma pessoa, sempre pelo nome! :)
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)
É 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! :)
------------------------------------------------------- // ------------------------------------------------------------
def exibeMensagem ( ):
print("Isso é uma mensagem!\n")
OBS: Se os parênteses estiverem vazios quer dizer que a função >> NÃO << recebe
nenhum parâmetro!
------------------------------------------------------- // ------------------------------------------------------------
EX: Faça uma função que recebe duas notas e seus respectivos pesos e retorne a média
ponderada:
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. :)
------------------------------------------------------- // ------------------------------------------------------------
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)
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 %!
------------------------------------------------------- // ------------------------------------------------------------
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 inicializamos com 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
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!
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
------------------------------------------------------- // ------------------------------------------------------------
x = 10
str(10)
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.
OBS: E além disso, retorna a quantidade de elementos de uma lista (Matéria da P2)
x = 7.5
type(x) #O tipo da variável x é float
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!
------------------------------------------------------- // ------------------------------------------------------------
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 >> i mport << 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!)
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)
num = random.randint(1,6)
alfabeto = "abcdefghijlmnopqrstuvwxyz"
print(random.choice(alfabeto))
OBS: As funções mais usadas são: uniform e randint. (As únicas que incluem os extremos
do intervalo)
------------------------------------------------------- // ------------------------------------------------------------
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 t este.py e colocamos uma função chamada
calcArea. Agora é só colocar na primeira linha de código da função a sua descrição!
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.
trl + N) O
Agora vamos criar um novo módulo chamado teste2.py (Use sempre o atalho C
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))
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
------------------------------------------------------- // ------------------------------------------------------------