Funcões

Na matemática uma função é um tipo particular de relação entre elementos de dois conjuntos, usualmente representada pela expressão: $ f: A \to B $ (lê-se: f de A em B), onde:

• f é o nome da função,
• A é chamado de domínio da função e
• B o codomínio da função.

A título de exemplo, considere a função $ f: \mathbb{N} \to \mathbb{N} $, dada por:

$ f(x) = 3x+2 $

A varíavel x é chamada de parâmetro da função e irá denotar um valor (o argumento) no domínio dos naturais ($\mathbb{N}$) que será passado no momento da avaliação (cálculo) da função, como em:

$f(4) = 14 \implies$ neste instante $x=4$, de forma que $f(4) = 3 \cdot 4 +2 = 14$

$f(8) = 26 \implies$ neste instante $x=8$, de forma que $f(8) = 3 \cdot 8 +2 = 26$

De forma similar, nas linguagens de programação também é possível definir funções. No caso da linguagem Python a definição de uma função é precedida pela palavra-chave "def".

# Definição da função f
def f(x):
    return 3 * x + 2

# Avaliação da função f
x = 10
print(f(x))
print(f(9))

Nas linhas 2 e 3 é definida a função $f(x)$ que tem x como parâmetro. A linha 3 indica como é calculado o valor do codomínio, com base no valor $x$ do domínio, sendo o resultado retornado (comando return) para o ponto onde a função foi avaliada.

Nas linhas 6 e 7 a função $f(x)$ é avaliada para os argumentos $x=4$ e $x=8$, respectivamente, sendo o resultado da avaliação da função (valor retornado nas linhas 2 e 3) apresentado (impresso) por meio da função $print$.

Outros exemplos, incluindo composição de funções

Sejam as funções $ f: \mathbb{N} \to \mathbb{N} $, $ g: \mathbb{N} \to \mathbb{N} $ e $ h: \mathbb{N} \to \mathbb{N} $ dadas por:

$f(x) = x + 6$

$g(x) = 4 f(x+2)$

$h(x) = f(x/2) + g(f(3x))$

Alguns exemplo de avaliação destas funções:

$f(4) = 4 + 6 = 10$

$f(24) = 24 + 6 = 30$

$f(32) = 32 + 6 = 38$

$g(2) = 4 f(2+2) = 4f(4) = 4 \cdot 10 = 40$

$g(30) = 4 f(30+2) = 4f(32) = 4 \cdot 38 = 152$

$h(8) = f(8/2) + g(f(3 \cdot 8)) = f(4) + g(f(24)) = 10 + g(30) = 10 + 152 = 162$

$g(f(4)) = g(10) = 4f(10+2) = 4f(12)= 4(12+6) = 4\cdot18 = 72$

Podemos construir as mesmas funções em Python, conforme linhas 1 a 8 abaixo. Quanto à avaliação das funções, linhas 10 a 16, ela segue o mesmo comportamento descrito acima.

def f(x):
    return x + 6

def g(x):
    return 4 * f(x+2)

def h(x):
    return f(x/2) + g(f(3*x))

print(f(4))
print(f(24))
print(f(32))
print(g(2))
print(g(30))
print(h(8))
print(g(f(4)))

Funções com vários parâmetros

Podemos também definir funções com vários parâmetros, a exemplo de:

$ f: \mathbb{N} \times \mathbb{N} \times \mathbb{R} \to \mathbb{R} $

com:

$ f(x, y, z) = 3x - \sqrt{(y-2)^2} +z$

Em Python esta função é implementada por:

import math

# Define uma função com três parâmetros
def f(x, y, z):
    return 3*x - math.sqrt((y-2)**2) + z

# Avalia a função f com: x=10, y=5, z=15 e imprime o resultado
print(f(10, 5, 15))

# Avalia a função f com: x=5, y=3.0, z=19
print(f(15//3, math.sqrt(9), 3*8-5))

# Obtém os valores de a, b e c por digitação via teclado
a = int(input("Digite com o valor de a: "))
b = int(input("Digite com o valor de b: "))
c = int(input("Digite com o valor de c: "))

# Avalia a função f com: x=a, y=b, z=c
print(f(a, b, c))