Esta semana vamos aprender a criar e usar funções em python.
As funções definem blocos de código, ao qual damos um nome, e que podemos chamar durante a execução do nosso programa. As funções servem principalmente para reduzir a repetição e organizar o código, dando nomes a tarefas que podemos identificar melhor e executar várias vezes durante a execução do programa.

Definição de funções: def

Para definirmos funções em python usamos instrução def, que tem a seguinte forma de utilização:

1
2
def nome_funcao(param1, param2):

    instruções

Em que o “nome_funcao” é um nome que queremos dar à função e “param1, param2″ são parâmetros, que são opcionais, e que podemos ter quantos quisermos.

Para executar uma função apenas temos de a chamar pelo nome e passar os parâmetros, da seguinte forma:

1
nome_funcao(param1, param2)

Exemplo:

1
2
3
4
def ola():

    print "Olá mundo"



ola()

Nota: Tudo o que for definido dentro de uma função, apenas será válido dentro dessa função. Por exemplo, se dentro de uma função definirmos uma variável “a”, essa variável só poderá ser usada dentro da função.

Parâmetros

As funções podem conter parâmetros, que são valores passados à função aquando da sua execução, e que podem ser usados como variáveis, mas apenas dentro da função.

Os parâmetros em python, normalmente são passados como referência, ou seja, se alterados dentro da função, os seus valores são modificados na variável passada como parâmetro. Mas existem excepções, como é o caso das strings, tupolos e números, que se forem alterados dentro da função não modificam a variável passada como parâmetro.

No exemplo a seguir temos uma função que soma e imprime os valores dos parâmetros “a” e “b”.

1
2
3
4
def soma(a, b):

    print a + b



soma(2, 5)

Também podemos definir parâmetros opcionais. Para isso devemos definir um valor padrão, que será passado, se aquando da execução não for passado nenhum valor.

Retomando o exemplo anterior, definimos um novo parâmetro c, que toma o valor padrão de 0 quando não é passado nenhum valor para c.

1
2
3
4
5
def soma(a, b, c = 0):

    print a + b + c



soma(2,5)

soma(2,5,3)

Retornar de uma função: return

Para quando queremos terminar a execução de uma função e/ou retornar um valor, usamos a instrução return que pode ou não retornar valores.

No exemplo seguinte, temos a função imprime, que imprime o elemento da lista passada como parâmetro, da posição passada no parâmetro index, mas verifica antes se a posição não é maior ou igual ao tamanho da lista, e caso o seja, retona da função, terminando a sua execução.

1
2
3
4
5
6
7
def imprime(lista, index):

    if index >= len(lista):

        return

    print lista[index]



imprime([], 2)

imprime([1, 2, 3], 2)

Já no exemplo seguinte, a função retorna um valor, que é o somatório dos valores passados como parâmetro.

1
2
3
4
def somar(a, b):

    return a + b



print somar(3, 5)

Também é possível retornar vários valores. Para isso, no return, temos de separar os valores por virgula, ou então retornar uma lista ou array de valores.
Para receber os valores de retorno em várias variáveis, temos de separar as variáveis por virgula, mas também é possível receber esses valores numa lista.

No exemplo a seguir, temos a função “proximos”, que retorna o número anterior e seguinte ao valor passado como parâmetro, e os valores retornados são guardados nas variáveis, “ant” e “seg” respectivamente.

1
2
3
4
5
6
def proximos(a):

    return a - 1, a + 1



ant, seg = proximos(10)

print "anterior:", ant

print "seguinte:", seg

Aceder a variáveis globais

Para aceder a uma variável global numa função temos de usar a instrução global, que tem a seguinte forma de uso:

1
global variavel

No exemplo a seguir acedemos à variável global num, para a incrementar:

1
2
3
4
5
6
num = 0

def incNum():

    global num

    num += 1



incNum()

Funções anónimas ou lambda

As funções anónimas ou lambda, são funções que como o nome indica, não tem nome, e que podem ser criadas e executadas em qualquer momento da execução do programa, não precisando de ser definidas, e que apenas retornam o valor de uma expressão, sem precisar do return.
Para criar uma função anónima, usamos a instrução lambda, que pode ser usada da seguinte forma:

1
lambda param1, param2: expressão

Exemplo:

1
2
inc = lambda x: x + 1

print inc(10)

Nota: Qualquer função pode ser atribuída a uma variável, e as funções lambda não são excepção, podendo depois ser executadas com o nome da variável.

Em baixo definimos a função “find”, que tem como parâmetros, uma lista e uma função, que será executada para cada elemento da lista, e que retorna verdadeiro ou falso, para validar se o elemento é o elemento a retornar. Depois na execução passamos uma lista e uma função lambda, que vai verificar se o item, que será passado como “x”, é igual a 7, ou seja, a função “find”, vai procurar por um elemento que seja igual a 7, retornando esse elemento.

1
2
3
4
5
def find(lista, func):

    for item in lista:

        if func(item): return item



print find([9, 4, 7, 2, 5], lambda x: x == 7)

Deixem a vossa opinião e sugestões, e se não perceberem perguntem, que eu terei todo o gosto em responder.
E pronto, é tudo por hoje. Para a semana há mais. Boa programação.

Artigos Relacionados:

1. Tutorial de Python – Loops ou Ciclos
2. Tutorial de Python – Strings e Arrays – Parte 1
3. Tutorial de Python – Variáveis Numéricas
4. Como fazer switch-case em python?