2ª unidade · atualLição 3 de 4~15 min de leitura9 fichas para praticar

Funções

Uma função é um pedaço de código com nome. Você escreve uma vez com def e usa quantas vezes quiser. Ela recebe valores pelos parâmetros, faz o trabalho e devolve o resultado com return.

Nesta lição0 de 5 vistas

1As partes de uma função
2O caminho que o programa faz
3return ou print?
4Cada função tem as suas variáveis
5Como montar a questão

As partes de uma função

def, nome, parâmetros, corpo e return

potencia.py

1def potencia(x, z):
2    resultado = 1
3    i = 0
4    while i < z:
5        resultado = resultado * x
6        i = i + 1
7    return resultado
8 
9print(potencia(2, 10))

Parte	O que é
`def`	avisa que vem uma função. Só cria; nada roda ainda
`potencia`	o nome, que você escolhe
`(x, z)`	os parâmetros: variáveis que recebem os valores da chamada
corpo indentado	o trabalho, igual ao de sempre
`return resultado`	termina a função e devolve o valor
`potencia(2, 10)`	a chamada: x recebe 2, z recebe 10, e a chamada vira 1024

O caminho que o programa faz

Pula para dentro da função e volta com o valor

A ordem de execução O Python passa pelo def só para guardar a função. O programa começa de verdade na primeira linha de fora. Na chamada, ele pula para dentro da função, roda até o return e volta para a mesma linha, com o valor no lugar da chamada.

Uma função por dentroentradas: 4

1def quadrado(x):
2    r = x * x
3    return r
4 
5a = int(input())
6b = quadrado(a)
7print(b + 1)

Nenhuma variável ainda.

Linha 1define a função quadrado(x). O corpo só roda quando ela for chamada.

a saída aparece aqui

1 / 8

return ou print?

Função devolve; procedimento só exibe

Função (com return)

exemplo.py

1def media(a, b):
2    return (a + b) / 2
3 
4m = media(6, 9)
5if m >= 7:
6    print('APROVADO')

Devolve um valor que o resto do programa usa: guarda, compara, soma. Enunciado com “retorna” ou “devolve”.

Procedimento (sem return)

exemplo.py

1def desenhaLinha(n):
2    print('-' * n)
3 
4desenhaLinha(10)

Faz o trabalho e exibe. É chamado sozinho na linha. Enunciado com “exibe”, “imprime” ou “procedimento”.

O que cada programa exibe?

Se exibir mais de uma linha, separe com espaço. Se der erro, escreva erro.

8 perguntas

def dobro(x):
    return x * 2
 
print(dobro(5) + 1)

def dobro(x):
    print(x * 2)
 
r = dobro(3)
print(r)

def f(n):
    n = n + 1
    return n
 
n = 5
f(n)
print(n)

def f(n):
    n = n + 1
    return n
 
n = 5
n = f(n)
print(n)

def eh_par(n):
    return n % 2 == 0
 
print(eh_par(7), eh_par(10))

def primeiro_negativo(v):
    i = 0
    while i < len(v):
        if v[i] < 0:
            return i
        i = i + 1
    return -1
 
print(primeiro_negativo([3, 8, -2, -5]))

def soma(a, b):
    s = a + b
    return s
 
soma(2, 3)
print(s)

def area(b, h=1):
    return b * h
 
print(area(4), area(4, 3))

Cada função tem as suas variáveis

Parâmetro é cópia; variável local some no fim

Parâmetro é cópia

Quando você chama f(n), o parâmetro recebe uma cópia do valor. Mudar o parâmetro lá dentro não muda o n de fora. O valor só sai pelo return.

Variável local some no fim

O que a função cria (o r, o i, a soma) existe só enquanto ela roda. Pode até ter o mesmo nome de uma variável de fora: são caixas diferentes.

Existe o global, que deixa a função mudar uma variável de fora, mas ele esconde de onde o valor veio. Nas listas do professor, tudo se resolve com parâmetros e return.

Como montar a questão

Recebe, devolve ou exibe, e quem lê

1Leia o enunciado procurando três coisas: o que a função recebe (os parâmetros), o que ela devolve (return) ou exibe (procedimento), e quem lê os dados.
2Escreva o def com os parâmetros e resolva o problema dentro dele como se os valores já existissem.
3Termine com return (função) ou sem ele (procedimento).
4Embaixo, sem indentação, o programa principal: lê, chama, exibe.

capicua.py

1def inverte(n):
2    inv = 0
3    while n > 0:
4        inv = inv * 10 + n % 10
5        n = n // 10
6    return inv
7 
8def capicua(n):
9    return n == inverte(n)
10 
11print(capicua(1221), capicua(123))

Uma função pode chamar outra: a capicua usa a função que inverte o número.

Erros que mais aparecem na prova

6 erros

Ler com input() dentro da função que recebe parâmetro.

Quando o enunciado diz “recebe por parâmetro”, o valor chega pronto na chamada. Quem lê é o programa principal. Um input() dentro da função ignora o parâmetro.

Trocar return por print.

print só mostra na tela; return devolve o valor para quem chamou usar. Se o enunciado diz “retorna”, é return. Com print, quem chamou recebe None.

Esquecer de guardar o que voltou.

Chamar f(n) sozinho na linha joga fora o valor devolvido. Guarde (r = f(n)) ou use direto (print(f(n))).

Chamar antes do def.

O Python lê de cima para baixo. A função precisa estar criada antes da linha que a chama. Coloque os def no começo e o programa principal no fim.

return dentro do laço sem querer.

O return termina a função na hora. Num laço que soma, um return na mesma indentação do soma = soma + x devolve já na primeira volta. O return da soma vai depois do laço, fora dele.

Usar a variável da função lá fora.

As variáveis criadas dentro da função somem quando ela termina. Para levar um valor para fora, só pelo return.

Próxima lição: Dicionários ›