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]:

Introdução à Programação em Python

Funções

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)


Entre com um valor: 10
2.302585092994046

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) ))


Entre com um valor: 3.14
-0.60480339246291

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:

  • um nome
  • o que ele receberá de entrada
  • o que ele retornará de saída

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))


310
75
-5

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)    )


310

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))


10 dividido por 3 é igual a 3.33 e sobra 1

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))


310

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


-2.18503986326

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()


Opcional

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))


[<matplotlib.lines.Line2D at 0x7fad513a3438>]

In [ ]: