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]:
Na aula anterior utilizamos algumas funções para realizar certas operações além das fundamentais.
In [3]:
import math
x = float(input("Entre com um valor: "))
y = math.log(x)
print(y)
Conceitualmente uma função é uma sequência de operações que realiza uma computação. Ou, um algoritmo que pode ser executado utilizando um nome.
Nos exemplos acima a função input() pode receber zero ou um parâmetro e devolve um valor, aquele digitado pelo usuário.
A função math.log() recebe um valor numérico e retorna um outro valor numérico, referente ao logarítmo da entrada.
Além de atribuir o(s) valore(s) de saída da função para variáveis, podemos também fazer a composição de funções. Digamos que queremos obter o valor de:
$$ cos(\frac{x}{\sqrt{2.0}})$$Nesse caso temos que o valor de x é dividido pelo valor da raíz de 2.0 para então calcularmos o cosseno do resultado.
In [4]:
x = float(input("Entre com um valor: "))
print(math.cos( x/math.sqrt(2.0) ))
Além das funções existentes, o Python permite criar novas funções que serão úteis ao longo do seu programa.
Para criar uma função é preciso definir:
Digamos que precisamos saber os valores da função $f(x) = 3x^2 + 2x - 10$ para diversos valores de $x$. Sabemos que a biblioteca math não tem tal função.
Vamos criar essa função no Python.
In [5]:
# o nome da minha função é minhaEq
def minhaEq(x): # ela recebe um valor x de entrada
return 3*x**2 + 2*x - 10 # retorna o valor da eq. do segundo grau
O comando def minhaEQ(x): indica que criaremos uma função.de nome minhaEQ e que receberá a entrada x definida dentro dos parênteses. O dois pontos (:) indica que a definição da função será escrita em seguida.
A linha seguinte utiliza a instrução return para dizer que o valor da expressão a seguir será retornada para quem chamou a função.
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 [6]:
# vamos criar novamente a função
def minhaEq(x):
return 3*x**2 + 2*x - 10
print(minhaEq(10) ) # ele retorna para a função print o valor de 3*10**2 + 2*10 - 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:
In [7]:
def eqGenerica(a,b,c,x):
# as próximas duas linhas tem o mesmo alinhamento
y = a*x**2 + b*x + c
return y
print(eqGenerica(3,2,-10,10) )
Vamos criar uma função que recebe duas variáveis, x e y, e retorna a média aritmética entre elas.
In [21]:
# Exercício
print(media(5,3))
print(media(2,10))
Uma função pode retornar mais do que uma variável também se necessário:
In [10]:
# faz uma divisão de inteiros, retornando
# o quociente e o resto
def DivideInt(x,y):
q = x/y # quociente
r = x%y # resto
return q, r
q,r = DivideInt(10,3)
print("10 dividido por 3 é igual a {:.3} e sobra {}".format(q, r))
E ela pode retornar qualquer um dos tipos que vimos até agora, até mesmo retornar uma função:
In [11]:
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))
Vamos praticar com alguns exercícios!
1) Crie uma função que retorne o valor da função seno dado por:
f(x) = A . sin(2*pi*freq*x + phi)sendo:
amplitude A, a frequencia freq,e a fase phi definidos pelo usuário, o valor de pi pode ser obtido usando math.pi
In [ ]:
import math
def MeuSeno(A,freq,phi,x):
# complete o seu código abaixo seguindo o alinhamento
# fim do código do aluno
return seno
print(MeuSeno(10.0, 1.0, 2.0, 10.0)) # resultado deve ser 9.09
2) Crie uma função que retorne os valores das funções seno e cosseno dados por:
f(x) = A . sin(2*pi*freq*x + phi)
f(x) = A . cos(2*pi*freq*x + phi)sendo:
amplitude A, a frequencia freq,e a fase phi definidos pelo usuário, o valor de pi pode ser obtido usando math.pi
In [ ]:
import math
def MinhaOnda(A,freq,phi,x):
# complete o seu código abaixo seguindo o alinhamento
# fim do código do aluno
return seno, cosseno
print(MinhaOnda(10.0, 1.0, 2.0, 10.0)) # resultado deve ser 9.09, -4.16
2) Crie uma função que retorne a tangente utilizando a função MinhaOnda().
In [24]:
def Tangente(A,freq,phi,x):
# escreva o seu código abaixo
# fim do código do aluno
return sen/cos
print(Tangente(10.0, 1.0, 2.0, 10.0)) # resultado deve ser -2.18
Vamos revisitar nosso programa de plotagem de gráfico da aula passada.
Como precisávamos das variáveis x e y=f(x) para plotar os pontos, tinhamos que construir as duas listas digitando cada um dos valores de x e f(x).
In [2]:
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(figsize=(5,5))
plt.style.use('fivethirtyeight')
x = [-5,-4,-3,-2,-1,0,1,2,3,4,5]
y = [25,16,9,4,1,0,1,4,9,16,25]
plt.plot(x,y, color='green')
plt.show()
Para construir a lista f(x) o Python tem a função
map( f, lista )
ela recebe duas entradas: uma função e uma lista de valores.
A função map aplica a função f em cada elemento de lista e retorna um gerador de listas, que deve ser convertido para lista com a função list()
In [21]:
# vamos usar a função que criamos anteriormente
def Quadrado(x):
return x*x
x = [-5,-4,-3,-2,-1,0,1,2,3,4,5]
y = list(map( Quadrado, x )) # equivalente a [Quadrado(-5),Quadrado(-4),,...]
plt.figure(figsize=(5,5))
plt.style.use('fivethirtyeight')
plt.plot(x,y, color='green')
plt.show()
Na biblioteca numpy temos também a função arange(inicio, fim, passo) que gera uma lista de valores entre inicio e fim de passo em passo.
In [4]:
from numpy import arange
import math
def MeuSeno(x):
return 10.0 * math.sin(2*math.pi*x + 2.0)
def MeuCos(x):
return 10.0 * math.cos(2*math.pi*x + 2.0)
def MeuTan(x):
return MeuSeno(x)/MeuCos(x)
plt.figure(figsize=(8,8))
plt.style.use('bmh')
plt.hold(True)
x = arange(-3,3,0.05) # gera [-3, -2.95, -2.9, ...]
y = list(map(MeuSeno, x) )
plt.plot(x,y, color='green')
y = list(map(MeuCos, x) )
plt.plot(x,y, color='red')
y = list(map(MeuTan, x) )
plt.plot(x,y, color='blue')
plt.show()
O Jupyter permite criar um gráfico interativo utilizando a função interact.
O primeiro parâmetro de interact é uma função que faz o trabalho de plotar o gráfico. Os próximos parâmetros são a faixa de valores que cada parâmetro da função pode ter. Ex.:
A = (1,5,2)
o parâmetro A pode ter valores de 1 a 5, aumentando de 2 em 2: [1,3,5]
In [5]:
# temos que usar a opcao inline
from IPython.html.widgets import interact
def plotaSenCosTan(freq):
def MeuSeno(x):
return 10.0 * math.sin(2*freq*math.pi*x + 2.0)
def MeuCos(x):
return 10.0 * math.cos(2*freq*math.pi*x + 2.0)
def MeuTan(x):
return MeuSeno(x)/MeuCos(x)
plt.figure()
plt.hold(True)
x = arange(-3,3,0.05)
y = list(map(MeuSeno, x) )
plt.plot(x,y, color='green')
y = list(map(MeuCos, x) )
plt.plot(x,y, color='red')
y = list(map(MeuTan, x) )
fig = plt.plot(x,y, color='blue')
plt.show()
return fig
interact(plotaSenCosTan, freq=(0.25,1.0,0.25))
In [ ]: