In [1]:
# ignore esse código inicial, é apenas para preparar a página
from IPython.display import YouTubeVideo, HTML, Image, display
css_file = './modelo.css'
HTML(open(css_file, "r").read())
Out[1]:
Imagine que queremos fazer um programa para calcular o valor da função f(x) = 3*x**2 + 2*x - 10. Com o que aprendemos até agora escreveríamos a expressão para cada valor de x que queremos avaliar. Ex.:
3*10**2 + 2*10 - 10
3*5**2 + 2*5 - 10
3*1**2 + 2*1 - 10
...
Isso ficaria muito repetitivo e seria interessante podermos simplesmente criar uma função no formato f(x) que retornaria o valor dessa equação para qualquer valor de x.
Em Python podemos criar funções utilizando a instrução def:
def minhaEq(x):
return 3*x**2 + 2*x - 10
A primeira linha define o nome da função e, entre parênteses, as variáveis que ela receberá. Na segunda linha a instrução return indica qual o valor que ela retornará. Ex.:
y = minhaEq(10)
retornará o valor de 3*10**2 + 2*10 - 10
NOTA: para o Python saber quais instruções pertencem a função ele verifica o alinhamento da instrução em relação a declaração da função. Utilizamos espaços para alinhar essas instruções, como convenção múltiplos de 4.
In [5]:
def minhaEq(x):
return 3*x**2 + 2*x - 10
print minhaEq(10)
print minhaEq(5)
print minhaEq(1)
As funções podem ter múltiplas variáveis se necessário e múltiplas instruções, desde que elas estejam alinhadas:
def eqGenerica(a,b,c,x):
y = a*x**2 + b*x + c
return y
Podemos retornar mais do que uma variável também se necessário:
def derivadaParcial(x,y):
dx = 2*x
dy = 2*y
return dx,dy
E ela pode retornar qualquer um dos tipos que vimos até agora, até mesmo retornar uma função:
def geraEq(a,b,c):
def eq2(x):
return a*x**2 + b*x + c
return eq2
In [6]:
def eqGenerica(a,b,c,x):
y = a*x**2 + b*x + c
return y
print eqGenerica(3,2,-10,10)
def derivadaParcial(x,y):
dx = 2*x
dy = 2*y
return dx,dy
d1,d2 = derivadaParcial(2,3)
print d1,d2
def geraEq(a,b,c):
# observem o alinhamento
# vou criar uma função que recebe x como entrada
# e retorna a eq. do segundo grau definida por
# a,b,c
def eq2(x):
return a*x**2 + b*x + c
# retorno minha função criada
return eq2
fx = geraEq(3,2,-10)
print fx(10)
In [ ]:
#Exercício 04
# Escreva o código logo abaixo das instruções,
# ao completar a tarefa clique em "Run" e
# verifique se a resposta está de acordo com
# o esperado
# 1) Crie uma função que retorne uma função
# quadrática de duas variáveis no seguinte formato:
# f(x,y) = a*x**2 + b*x**2 + c*x + d*y + e
# o usuário definirá os valores de a,b,c,d,e
def minhaEq(a,b,c,d,e):
fxy = minhaEq(2,3,2,1,4)
print fxy(2,3) # resultado 46
# 2) Crie uma função que retorne uma função
# de derivada dessa mesma função quadrática
def minhaDerivada(a,b,c,d):
dfxy = minhaDerivada(2,3,2,1)
print dfxy(2,3) # resultado 10 e 19
# 3) Crie uma função que retorne uma lista com
# os zeros das duas derivadas parciais
def listaZeros(a,b,c,d):
print listaZeros(2,3,2,1) # resultado [-0.5, -0.16]
O Python conta com diversas bibliotecas que automatizam muitas tarefas e permitem realizarmos experimentos interessantes.
Uma biblioteca útil para o BC&T é a matplotlib que permite plotar gráficos diversos. Para usá-la no iPython Notebook basta executar o comando:
%pylab inline
Vamos plotar alguns pontos de nossa função quadrática utilizando o comando plot(x,y), onde x e y são listas com valores correspondentes a abscissa e ordenada, respectivamente. Basicamente temos que x será uma lista de pontos que queremos plotar e y a aplicação da função fx() em cada ponto de x.
DICA: Podemos aplicar uma função em cada ponto de uma lista utilizando o comando
map( funcao, lista )
In [8]:
%pylab nbagg
x = [-5,-4,-3,-2,-1,0,1,2,3,4,5]
y = map(fx,x) # equivalente a [fx(-5),fx(-4),fx(-3),,...]
plot(x,y)
Out[8]:
In [8]: