Funções I

Criando nossos próprios comandos

Simplificando as coisas

Funções são, entre muitas coisas, uma das formas de evitarmos duplicação de código, assim como as Estruturas de Repetição. Mas elas ainda nos permitem modularizar nosso código.

Modularizar o código é, em poucas palavras, separar códigos em pedaços que podem ser reutilizados em outros vários lugares dos nossos projetos. Nosso objetivo é tornar o desenvolvimento dos nossos projetos mais simples de ser escrito, mantido e utilizado.

PEPs e PEP20

PEP é a sigla em inglês para Python Enhancement Proposals (
Propostas de Aprimoramento do Python) e possui recomendações e convenções para uma melhor escrita de códigos Python.

Cada uma das propostas possui um número. Neste momento, iremos verificar a PEP 20, conhecida como O Zen do Python e foi escrita por Tim Peters — um dos maiores contribuidores desta linguagem de programação.

Para visualizá-la, basta iniciarmos o Python (pelo terminal ou pelo IDLE) e executarmos o comando import this:

Python 3.6.3 (default, Mar 20 2018, 13:50:41) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-16)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Uma tradução direta feita pelo Google tradutor é a seguinte:

O Zen do Python, por Tim Peters
Bonito é melhor que feio.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Plano é melhor que aninhado.
Esparso é melhor que denso.
Legibilidade conta.
Casos especiais não são especiais o bastante para se quebrar as regras.
Embora a simplicidade supere o purismo.
Erros nunca deveriam passar silenciosamente.
A menos que explicitamente silenciados.
Ao encarar a ambiguidade, recuse a tentação de adivinhar.
Deveria haver uma – e preferencialmente apenas uma – maneira óbvia de se fazer isto.
Embora aquela maneira possa não ser óbvia à primeira vista se você não for holandês.
Agora é melhor que nunca.
Embora nunca, seja muitas vezes melhor que pra já.
Se a implementação é difícil de explicar, é uma má idéia.
Se a implementação é fácil de explicar, pode ser uma boa idéia.
Namespaces são uma idéia estupenda – vamos fazer mais deles!

A partir de agora, tenha em mente esse “mandamentos” na criação de novos códigos. Não basta saber programar, precisamos programar da melhor forma possível.

“Lembre-se, com grandes poderes vêm grandes responsabilidades.”

Nota: Documentação oficial do Python para a PEP 20.
Nota²: Documentação oficial do Python contendo a lista de todas as PEPs e suas classificações.

Já estamos habituados a funções

Já fazemos o uso de funções desde o início quando imprimimos nossa primeira mensagem no terminal. Por exemplo, os comandos print, input, len, etc., são funções que já utilizamos. E, não só isso, fazem parte das funções bult-in do python — funções que já fazem parte da linguagem.

Nota: Outras funções built-in podem ser vistas na documentação.

‘Def’inindo novas funções

A definição de uma nova função é feita com o comando def e sua sintaxe é a seguinte:

def <nome>(<parâmetros>):
    <escopo da função>
    return <retorno>

Alguns detalhes sobre cada componente de uma função:

Nome

Deve ser escrito sem utilizar espaços, por exemplo:

# Nome bom!
def minha_funcao():
# Nome ruim!
def minha funcao():
# Nome aceitável
def minhaFuncao():

Parâmetros (opcional)

Também são conhecidos como argumentos ou entradas da função. Podem existir parâmetros ou não. Caso haja mais de um, eles devem ser separados por vírgulas. Por exemplo:

# Função com 3 argumentos/parâmetros
def minha_funcao(arg1, arg2, arg3):

Escopo

Deve estar indentado com quatro espaços, assim como fazemos com if, for, while, etc.

Retorno

O comando é o return. Também conhecido como saída da função. É utilizado para encerrar a função e, também, para levar um ou mais objetos para o escopo que a chamou.

Não declarando o return, ele é feito automaticamente no final da função e retorna None (nada).

# Função que retorna nenhum valor
def retornaNada():
    faz_nada = True
# Função que um valor
def retornaUm():
    return 1
# Retorna dois valores
def retornaDois():
    return 1, "dois"

Exemplos

Vejamos alguns exemplos de definições de funções e os seus usos:

• Função que exibe uma mensagem de boas vindas com um nome:

# Imprime uma mensagem de boas vindas contendo um nome!
def boas_vindas(nome):
    msg = "Seja muito bem vindx, {}".format(nome)
    print(msg)
# Utilizando a função:
boas_vindas("Lucas")
boas_vindas("Márcia")
boas_vindas("Bryan")
boas_vindas("Eduarda")

A função boas_vindas contém um parâmetro (nome) e nenhuma saída.

• Função que informa a paridade de um número (par ou ímpar):

# Informa a paridade de um número passado como argumento
def paridade(numero):
    if numero % 2 == 0:
        return "par"
    else:
        return "impar"
# Utilizando a função
num = 5
print("O numero {} é {}".format(num, paridade(num)))

A função paridade contém um parâmetro (numero) e uma saída (uma string).

• Função que realiza a média das notas de 3 provas:

# Retorna a média das provas
def media(p1, p2, p3):
    media = (p1 + p2 + p3)/3
    return media
# Utilizando a função
print(media(9, 5, 8))
print(media(9, 8, 9))
print(media(2, 5, 3))

A função media contém três parâmetros (p1, p2 e p3), separados por vírgula, e uma saída (media).

• Função que separa os números pares e ímpares de uma lista inserida como argumento:

# Informa se um número é par
# Retorna True se é par e False se é ímpar 
def eh_par(numero):
    if numero % 2 == 0:
        return True
    else:
        return False
# Separa elementos da lista entre pares e ímpares
def separaPorParidade(numeros):
    pares = []
    impares = []
    for numero in numeros:
        if eh_par(numero):
            pares.append(numero)
        else:
            impares.append(numero)
    return pares, impares
# Utilizando a função
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pares, impares =  separaPorParidade(nums)
print(pares)
print(impares)

A função separaPorParidade contém um parâmetro (numeros — que é uma lista) e duas saídas (pares e impares — que são listas), separados por virgula.

Exercícios

Faça os exercícios recomendados para esta seção:

10. Exercícios Funções