2016 Dr. Walter F. de Azevedo Jr. azevedolab.net

(1)

© 2 0 1 6 Dr . W a lte r F . d e A z e v e d o Jr . 1 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000000000000000010000000000000 000000000000000000000111111111100000000 000000000000000000001111110000000000110 000000000000110000001111100000000111110 000000000001000011001111111111111111000 000000000010001110110001111111000000000 000000000011111111111111111111111110000 000001111111111111111111111111111110000 000000111111111111111111111111110000000 000000000111111111111111111111000000000 000000000111111111111111110000000000000 000000000111111111111111111110000000000 000000001111101111111111111111000000000 000000001111100111111111111111000000000 000000000000111111111111110011100000000 000000000000001111111110111111100000000 000000000000001110000011101100000000000 000000000000000000011111001100000000000 000000000000000000000000110000000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 azevedolab.net

(2)

Uma das características da linguagem de programação Python é a possibilidade de uso de bibliotecas gratuitas para gráficos e análise numérica. Nas próximas aulas, introduziremos as bibliotecas Matplotib, NumPy, SciKit-Learn e SciPy. Ao instalarmos o Python, por meio do Pyzo, já temos estas bibliotecas instaladas. Hoje veremos alguns recursos das bibliotecas Matplotlib e NumPy.

2 Matplotlib

www.python.org

Página de entrada do matplotlig: http://matplotlib.org/

(3)

import matplotlib.pyplot as plt import numpy as np

# Defines x range with linspace

x = np.linspace(0, 2*np.pi, 100)

# Defines sine function sine_func = np.sin(x) # Creates plot

plt.plot(x, sine_func) # Shows plot

plt.show()

# Saves plot on png file plt.savefig('sine1.png')

Vejamos o uso das bibliotecas Matplotlib e NumPy, para gerarmos o gráfico do seno. A primeira linha de código importa a biblioteca matplotlib para gráfico como plt. Assim, todos os recursos desta biblioteca podem ser chamados a partir da notação dot (.). O mesmo acontece na segunda linha de código, com a biblioteca numpy, importada como

np. O método .linspace() gera um conjunto de números floats, entre os intervalos

mostrados, no caso, entre 0 e 2*Pi. O valor de Pi pode ser chamado com numpy, por meio de np.pi. O último número, dentro dos parênteses do método linspace(), indica o número de pontos gerados, incluindo os valores máximo e mínimo.

3

Programa: sine1.py

(4)

# Defines sine function

sine_func = np.sin(x)

# Creates plot

plt.plot(x, sine_func)

# Shows plot plt.show()

Os números gerados com o método np.linspace(0,2*np.pi,100) são atribuídos à variável

x. Veja que o último número (100) indica o número de floats gerados no intervalo

estabelecido, pelos dois primeiros números, dentro dos parênteses, o que inclui os números 0 e 2Pi.

A linha de comando sine_func = np.sin(x) define a função seno, a partir da biblioteca

numpy. O resultado é atribuído à variável sine_func. O método plt.plot(x,sine_func) gera

o gráfico cartesiano, os valores do eixo x são aqueles atribuídos à variável x, e os valores do eixo y, são aqueles atribuídos à variável sine_func.

4

(5)

# Defines sine function

sine_func = np.sin(x)

# Creates plot

# Shows plot

plt.show()

# Saves plot on png file

plt.savefig('sine1.png')

O método plt.show() mostra o gráfico na tela. Este método pode ter resultados diferentes, conforme a instalação da biblioteca Matplotlib e o sistema operacional que você está utilizando. O método plt.savefig(‘sine1.png’) salva o gráfico gerado no arquivo

sine1.png. Execute o código sine1.py e clique na pasta da aula de hoje. Localize o

arquivo sine1.png e clique duas vezes neste. Veja o gráfico gerado.

5

(6)

Abaixo temos o gráfico da função seno, gerado pelo programa sine1.py.

6

(7)

# Defines x range with linspace x = np.linspace(0, 2*np.pi, 100) # Defines sine function

sine_func = np.sin(x) # Creates plot

plt.xlabel('x-axis') # Adds axis label plt.ylabel('y-axis') # Adds axis label plt.title('Sine Function') # Adds title

plt.grid(True) # Adds grid to the plot

Como em toda biblioteca gráfica, podemos adicionar os nomes dos eixos, gradeado e título, com os métodos destacados em vermelho no código sine2.py. Os métodos

plt.xlabel(), plt.ylabel() e plt.title() aceitam variáveis como argumentos, ou strings, como

no código abaixo.

7

(8)

Abaixo temos o gráfico da função seno, gerado pelo programa sine2.py.

8

(9)

# Defines x range with linspace x = np.linspace(0, 2*np.pi, 100) # Defines sine and cosine functions sine_func = np.sin(x)

cos_func = np.cos(x)

# Creates plots

plt.plot(x, sine_func) plt.plot(x, cos_func)

plt.xlabel('x-axis') # Adds axis label plt.ylabel('y-axis') # Adds axis label

plt.title('Sine and Cosine Functions') # Adds title plt.grid(True) # Adds grid to the plot # Shows plot

plt.show()

# Saves plot on png file plt.savefig('trig1.png')

O programa trig1.py gera o gráfico para as funções seno e cosseno. Para isto basta adicionarmos a variável cos_func, e atribuirmos a ela o resultado do método np.cos(x).

9

Programa: trig1.py

(10)

# Defines x range with linspace x = np.linspace(0, 2*np.pi, 100) # Defines sine and cosine functions sine_func = np.sin(x)

cos_func = np.cos(x)

# Creates plots

plt.plot(x, cos_func)

plt.title('Sine and Cosine Functions') # Adds title

plt.grid(True) # Adds grid to the plot # Shows plot

plt.show()

# Saves plot on png file plt.savefig('trig1.png')

Temos que adicionar o método plt.plot(x,cos_func) para o gráfico do cosseno, como indicado abaixo. Mudamos também o título do gráfico.

10

(11)

Abaixo temos o gráfico das funções seno cosseno, geradas pelo programa trig1.py. Veja que linha do cosseno é verde.

11

(12)

Podemos acionar o método plt.plot() quantas vezes forem necessárias. Os gráficos se sobrepõem.

12

(13)

Resumo

Programa para gerar os gráficos da função seno e cosseno, a partir das bibliotecas

Matplotlib e NumPy. O usuário digita a faixa de valores para o eixo x e os títulos dos eixos

x,y, bem como o título do gráfico e o nome do arquivo de saída. Ambas funções são colocadas no mesmo gráfico. O programa gera o arquivo de saída no formato PNG.

Gráfico das funções seno e cosseno

Programa: trig2.py

13

(14)

# Imports libraries

# Reads input information

x_min = float(input("Type minimum value for x-axis => ")) x_max = float(input("Type maximum value for x-axis => ")) x_label = input("Type x-axis label => ")

y_label = input("Type y-axis label => ") plot_title = input("Type plot title => ")

output_file = input("Type output file name => ")

14

A principal novidade do código trig2.py é que as informações, para gerarmos o gráfico, são lidas a partir de entradas digitadas pelo usuário. Para isto precisamos da função

input(), como indicado no trecho em vermelho abaixo. Os valores mínimo e máximo do

eixo x são convertidos para float. As informações são atribuídas às variáveis x_min e

x_max. As outras informações são strings, e não devem ser convertidas. Programa: trig2.py

(15)

# Defines x range with np.linspace()

x = np.linspace(x_min, x_max, 100)

# Defines sine and cosine functions sine_func = np.sin(x)

cos_func = np.cos(x) # Creates plots

plt.plot(x,sine_func) plt.plot(x,cos_func)

plt.xlabel(x_label) # Adds axis label plt.ylabel(y_label) # Adds axis label plt.title(plot_title) # Adds title

plt.show() # Saves plot

plt.savefig(output_file) 15

Os valores atribuídos às variáveis de entrada são usados como argumentos para a chamada de funções para gerarmos o gráfico. As linhas de código, que usam os valores atribuídos às variáveis, estão indicadas em vermelho. A função plt.grid(True) não precisa de variável, ela tem como argumento o valor lógico True, que habilita o desenho de grades no gráfico.

(16)

16

Abaixo temos os dados de entrada e o gráfico gerado.

www.python.org

Type minimum value for x-axis => 0 Type maximum value for x-axis => 12.6 Type x-axis label => x-axis

Type y-axis label => y-axis

Type plot title => Trigonometric functions Type output file name => trig2.png

(17)

Resumo

Programa para gerar os gráficos da função seno ou cosseno, a partir das bibliotecas

Matplotlib e NumPy. O usuário escolhe que função será gerada e digita a faixa de valores

para o eixo x e os títulos dos eixos x,y, bem como o título do gráfico e o nome do arquivo de saída. Só uma função é gerada. O programa gera o arquivo de saída no formato PNG.

Gráfico das funções seno ou cosseno

Programa: trig3.py

17

(18)

Já vimos alguns programas para gráficos de funções trigonométricas. Veremos agora, com mais detalhes, diversos programas em Python para gerar gráficos, a partir de recursos da biblioteca Matplotlib. Abaixo temos um código simples, para exibição de pontos num gráfico bidimensional. As linhas de código estão em vermelho, os comentários em preto. A primeira linha importa a biblioteca Matplotlib como plt. Depois temos a linha com o comando .plot(), onde foram especificados 8 valores, que representam coordenadas no eixo y. A biblioteca Matplotlib usa valores implícitos para o eixo x, começando em zero até o valor inteiro N-1, onde N é o número de itens na lista. O comando .show() mostra o gráfico na tela. Por último, o comando .savefig(), salva o arquivo com o gráfico gerado.

18

Programa: simple_plot1.py

www.python.org

import matplotlib.pyplot as plt

# Generates a simple plot

plt.plot([1,1,2,3,5,8,13,21])

# Shows plot

plt.show()

(19)

Abaixo temos o gráfico gerado.

19

www.python.org

# Generates a simple plot

plt.plot([1,1,2,3,5,8,13,21])

# Shows plot

plt.show()

(20)

# Program to illustrate the use of Matplotlib import matplotlib.pyplot as plt import numpy as np # Generates x-axis x = np.arange(0,8,0.01) # Generates y-axis y = x**2 # Generates plot plt.plot(x,y) # Shows plot plt.show()

plt.savefig("simple_plot2.png")

Já vimos em Python a função range(i,j,k), que gera uma lista de inteiros, iniciando em i e finalizando no número imediatamente antes de j, com um passo k. Usaremos uma função da biblioteca NumPy, chamada np.arange(x,y,z), que gera uma sequência de números, não necessariamente inteiros. Esta sequência inicia em x, termina em um número antes de y e tem um passo z. Vejamos o código do programa simple_plot2.py, que gera uma parábola entre zero e 7.99. As linhas de código estão em vermelho.

20

(21)

Inicialmente importamos a bibliotecas Matplotlib e NumPy. Em seguida chamamos a função np.arange() que gera uma sequência de números, entre 0 e 7.99, com passo 0.01. Depois geramos o eixo y, com y = x**2. Com plt.plot(x,y) geramos os gráfico. O comando plt.show() mostra o gráfico na tela e plt.savefig() salva o arquivo com o gráfico. Efetivamente com 7 linhas de código geramos nosso gráfico.

21

(22)

Abaixo temos o gráfico gerado.

22

(23)

Resumo

Programa para gerar o gráfico da função raiz quadrada, a partir das bibliotecas Matplotlib e

NumPy. O usuário escolhe a faixa de valores para o eixo x e os títulos dos eixos x,y, bem

como o título do gráfico e o nome do arquivo de saída. Só uma função é gerada. O programa gera o arquivo de saída no formato PNG.

Gráfico da função raiz quadrada

Programa: simple_plot3.py

23

(24)

# Program to illustrate the use of Matplotlib

# Generates x-axis

x = np.arange(0,8,0.01)

# Generates y-axis and respective plot

y = x**2

plt.plot(x,y)

y = x**2.5 plt.plot(x,y)

y = x**3

plt.plot(x,y)

# Shows plot

plt.show()

plt.savefig("multiple_plots1.png")

Vejamos agora um programa com gráficos múltiplos. O programa multiple_plots1.py gera três curvas num mesmo gráfico para a mesma faixa de x.

24

Programa: multiple_plots1.py

(25)

x = np.arange(0,8,0.01)

y = x**2

plt.plot(x,y)

y = x**2.5 plt.plot(x,y)

y = x**3

plt.plot(x,y)

# Shows plot

plt.show()

A principal novidade do código é que geramos o eixo y três vezes e, em cada vez, chamamos o comando plt.plot(x,y). Como mudamos o y, temos três gráficos distintos.

25

(26)

x = np.arange(0,8,0.01)

y = x**2

plt.plot(x,y)

y = x**2.5 plt.plot(x,y)

y = x**3

plt.plot(x,y)

# Shows plot

plt.show()

Abaixo temos o gráfico gerado. Veja que a biblioteca Matplotlib gera as curvas em cores diferentes, a primeira curva em azul, depois verde e a última a linha vermelha.

26

(27)

# Program to illustrate the use of Matplotlib import matplotlib.pyplot as plt

import numpy as np # Generates x-axis

x = np.arange(0,8,0.01)

# Generates all plots in one command

plt.plot(x,x**2,x,x**2.5,x,x**3 )

plt.savefig("multiple_plots2.png") 27

www.python.org

Podemos gerar as três curvas com um comando plt.plot() somente, como indicado na linha de código em vermelho abaixo. O programa multiple_plots2.py tem um número menor de linhas e gera o mesmo gráfico.

(28)

x = np.arange(0,8,0.01)

# Generates all plots in one command

plt.plot(x,x**2,x,x**2.5,x,x**3 )

plt.savefig("multiple_plots2.png") 28

www.python.org

(29)

plt.plot(x,x**2,label=“Function x**2” )

29

www.python.org

Vimos com o programa trig2.py, como incluir informações diversas, tais como, rótulos para os eixos, título do gráfico, além do gradeado de fundo do gráfico, como se fosse um papel milimetrado. Agora vamos colocar legendas no nosso gráfico. Para incluirmos tais legendas, adicionamos a palavra chave label, como argumento da função plt.plot(). Por exemplo, para adicionarmos a legenda “Function x**2”, temos que usar o comando:

Após a inclusão da palavra chave “label”, precisamos da função plt.legend(), que insere a legenda criada no gráfico. As opções de posicionamento da legenda, com a palavra chave loc, são as seguintes: best, upper right, upper left, lower left, lower right, right,

center left, center right, lower center, upper center, center. Abaixo temos o comando,

para posicionarmos a legenda à esquerda acima.

No próximo slide, temos o código completo para o programa multiple_plot3.py .

(30)

x = np.arange(0,8,0.01)

# Generates plots with legends

plt.plot(x,x**2,label="Function x**2" ) plt.plot(x,x**2.5,label="Function x**2.5" ) plt.plot(x,x**3,label="Function x**3" )

# Positioning the legends

plt.legend(loc='upper left')

plt.title('Multiple Functions') # Adds title

plt.show()

O programa multiple_plot3.py traz informações completas sobre o gráfico gerado.

30

(31)

x = np.arange(0,8,0.01)

# Generates plots with legends

plt.plot(x,x**2,label="Function x**2" ) plt.plot(x,x**2.5,label="Function x**2.5" ) plt.plot(x,x**3,label="Function x**3" )

# Positioning the legends

plt.legend(loc='upper left')

plt.title('Multiple Functions') # Adds title

plt.show()

O gráfico está mostrado abaixo.

31

(32)

# Program to generate a histogram plot for a distribution of pseudo-random numbers import matplotlib.pyplot as plt

import numpy as np

# Generates an array of pseudo-random numbers using np.random.randn()

y = np.random.randn(1000)

# Generates plot

plt.hist(y)

plt.savefig("histogram_plot1.png") 32

Programa: histogram_plot1.py

www.python.org

A biblioteca Matplotlib tem diversas opções de gráficos, como histograma. O programa

histogram_plot1.py gera uma lista de número aleatórios e faz o gráfico da ocorrência

destes números, dividido em faixas. Para gerar os números aleatórios, usamos a função

np.random.randn(1000), que gera um array com 1000 números, que seguem uma

distribuição gaussiana. Para mostrar o histograma, usamos plt.hist.(y), que gera o histograma dividido em 10 faixas. O valor 10 é o padrão, podemos modificar o número de faixas, a partir da inclusão do número de faixas desejado como argumento da função

(33)

# Generates plot

plt.hist(y)

www.python.org

Abaixo temos o histograma gerado, vemos que o eixo y indica a ocorrência da faixa indicada no eixo x.

(34)

# Generates plot

plt.hist(y, 20)

www.python.org

O programa histogram_plot2.py gera um histograma com 20 divisões, como mostrada na figura abaixo. Só modificamos as linhas indicadas em vermelho.

(35)

# Program to generate a scatter plot for two distributions of pseudo-random numbers import matplotlib.pyplot as plt

# Generates two arrays of pseudo-random numbers using np.random.randn()

x = np.random.randn(1000) y = np.random.randn(1000) # Generates plot plt.scatter(x, y) # Shows plot plt.show()

plt.savefig("scatter_plot1.png") 35

Programa: scatter_plot1.py

www.python.org

Outro gráfico usado para estudo de distribuições, é o gráfico de dispersão. Na biblioteca

Matplotlib temos a função plt.scatter(), que gera gráficos de dispersão. No programa scatter_plot1.py, temos a aplicação da função np.random.randn(1000) duas vezes, uma

para gerar os números do eixo x e outra para gerar os números do eixo y. A função

plt.scatter(x,y) faz o gráfico de distribuição dos números aleatórios. O código está

(36)

# Program to generate a scatter plot for two distributions of pseudo-random numbers import matplotlib.pyplot as plt

# Generates two arrays of pseudo-random numbers using np.random.randn()

x = np.random.randn(1000) y = np.random.randn(1000) # Generates plot plt.scatter(x, y) # Shows plot plt.show()

www.python.org

(37)

# Program to generate a scatter plot for two distributions of pseudo-random numbers, using also random number

# for size and colors

# Generates four arrays of pseudo-random numbers using np.random.randn()

x = np.random.randn(1000) y = np.random.randn(1000)

size = 50*np.random.rand(1000) colors = np.random.rand(1000)

# Generates plot

plt.scatter(x, y, s = size, c = colors)

www.python.org

Vamos modificar o código scatter_plot1.py, para que tenhamos cores nos pontos do gráfico e que tenhamos os tamanhos do pontos variáveis. As cores e os tamanhos dos ponto irão variar de forma aleatória. Para gerarmos cores, usarmos a palavra chave c como argumento da função plt.plot(). No caso do tamanho do ponto do gráfico, usamos a palavra chave s. Assim, criamos distribuições aleatórias para variáveis size e colors. Para a variável size, temos que multiplicar por 50, visto que é expresso em pixels. O código está mostrado abaixo.

(38)

# Program to generate a scatter plot for two distributions of pseudo-random numbers, using also random number

# for size and colors

# Generates four arrays of pseudo-random numbers using np.random.randn()

x = np.random.randn(1000) y = np.random.randn(1000)

size = 50*np.random.rand(1000) colors = np.random.rand(1000)

# Generates plot

plt.scatter(x, y, s = size, c = colors)

www.python.org

(39)

39

www.python.org

O programa scatter_plot3.py traz como novidade o array do eixo y, gerado a partir de uma função linear com um componente de ruído.

Usamos a função da biblioteca NumPy np.random.normal(loc = 0,scale = 1.0, size =

100), que indica uma distribuição gaussiana gerada em torno de zero, com desvio

padrão de 1.0. Um total de 100 números aleatórios são gerados para o array.

np.random.normal(loc = 0,scale = 1.0, size = 100)

Indica o ponto central da distribuição

Indica o desvio padrão da distribuição de Gaus, ou seja, quanto maior o desvio, mais distribuídos estarão os pontos.

Número de pontos da distribuição de Gauss

(40)

import matplotlib.pyplot as plt # Generates array for x-axis x = np.linspace(0,10,100)

# Generates array y-axis with np.random.normal() for a noise component

y = 2*x + 1.5*np.random.normal(size=100)

# Generates plot plt.scatter(x,y) # Shows plot

plt.show()

plt.savefig('scatter_plot3.png')

40

www.python.org

(41)

# Generates array y-axis with np.random.normal() for a noise component

y = 2*x + 1.5*np.random.normal(size=100)

# Generates plot plt.scatter(x,y) # Shows plot

plt.show()

plt.savefig('scatter_plot3.png')

41

www.python.org

(42)

42

www.python.org

Usaremos a distribuição de pontos, gerada pelo programa scatter_plot3.py, para introduzir uma função importantíssima para computação científica, o ajuste de curva. A partir de uma distribuição de pontos, podemos ajustar uma curva teórica aos pontos. O gráfico de espalhamento abaixo, tem claramente uma distribuição em torno de uma reta. Nós já sabemos qual reta, pois foi gerado o array y = 2.x, mas há situações onde não sabemos a reta, ou a curva que melhor se ajusta a uma dispersão de pontos. A biblioteca NumPy tem a função np.polyfit(x,y, n), que determina um polinômio de grau n, que melhor explica os pontos dos arrays x e y.

np.polyfit(x,y,1)

Array x Array y

(43)

43

www.python.org

Outra função da biblioteca NumPy é a np.poly1d(), que gera um polinômio, a partir dos coeficientes dados como argumento. Usado após a função z = np.polyfit(x,y, 1), a função p = np.poly1d(z), retorna o polinômio que foi obtido para o ajuste da curva.

np.poly1d(z)

(44)

# Generates array y-axis with np.random.normal() for a noise component y = 2*x + 1.5*np.random.normal(loc = 0,scale = 1.0, size = 100)

# Generates plot plt.scatter(x,y)

# Least-squares polynomial fitting z = np.polyfit(x,y,1)

p = np.poly1d(z)

print("Best fit polinomial equation: ",p)

# Generates plot

plt.plot(x, p(x), '-') # Shows plot

plt.show()

plt.savefig('scatter_plot4.png') 44

O código está mostrado abaixo. O bloco em vermelho destaca a parte do ajuste da curva.

(45)

Best fit polinomial equation: 2.047 x - 0.2116

45

O gráfico está mostrado abaixo. Veja que a equação para melhor reta gerada é mostrada na tela.

(46)

46

www.python.org

Do ponto de vista de aplicação científica, seria interessante a possibilidade de lermos os pontos dos arrays x e y a partir de um arquivo externo. Você provavelmente já fez este processo, por exemplo, quando abriu uma planilha do Excel. O programa Excel usa como um dos formatos para suas planilhas, o formato CSV (Comma Separated

Values). Arquivo no formato CSV tem os valores separados por vírgulas, como

mostrado no trecho abaixo.

Name,MolDock Score,Rerank Score,RMSD,Interaction,Internal,HBond,LE1,LE3,Docking Score,DisplacedWater [291]SCF_501 [A],-135.265,-108.212,0.550558,-136.511,16.8594,-3.70663,-5.63606,-4.50883,-135.927,-15.6138 [278]SCF_501 [A],-135.279,-108.201,0.552119,-136.537,16.8903,-3.69755,-5.63661,-4.5084,-135.93,-15.632 [261]SCF_501 [A],-135.287,-108.197,0.553228,-136.515,16.8589,-3.69596,-5.63694,-4.50822,-135.939,-15.6301 [258]SCF_501 [A],-135.29,-108.195,0.551817,-136.507,16.8532,-3.69173,-5.63708,-4.50813,-135.942,-15.6365 [267]SCF_501 [A],-135.289,-108.18,0.553158,-136.595,16.9356,-3.68408,-5.63702,-4.5075,-135.935,-15.6291 [299]SCF_501 [A],-135.282,-108.164,0.554487,-136.586,16.9128,-3.67745,-5.63676,-4.50681,-135.925,-15.609 [256]SCF_501 [A],-135.297,-108.161,0.554416,-136.553,16.8902,-3.68148,-5.63736,-4.5067,-135.943,-15.6342 [252]SCF_501 [A],-135.295,-108.159,0.553906,-136.553,16.8732,-3.68676,-5.63729,-4.50663,-135.947,-15.6148 [257]SCF_501 [A],-135.291,-108.158,0.553521,-136.558,16.8822,-3.68676,-5.63712,-4.50657,-135.943,-15.6151 [265]SCF_501 [A],-135.291,-108.153,0.553381,-136.626,16.9517,-3.68131,-5.63712,-4.50638,-135.937,-15.6163 [272]SCF_501 [A],-135.283,-108.153,0.553865,-136.602,16.9356,-3.69094,-5.63678,-4.50639,-135.934,-15.6167

(47)

47

www.python.org

A função np.genfromtxt(‘data1.csv', delimiter=",", skip_header = 1) lê o arquivo

data1.csv e considera as colunas de dados estão separadas por vírgulas, opção

indicada por delimiter=",". Além disso, é desconsiderada a primeira linha do arquivo CSV, com a opção skip_header = 1, que pula a primeira linha. Abaixo temos a indicação dos principais argumentos da função np.genfromtxt().

np.genfromtxt(‘data1.csv', delimiter=",", skip_header = 1)

Nome do arquivo CSV

Indica o símbolo usado para separar as colunas, no caso são vírgulas “,”.

Número de linhas que serão puladas a partir da primeira, no caso pula-se a primeira linha.

(48)

# Reads CSV file

my_csv = np.genfromtxt (‘data1.csv', delimiter=",", skip_header = 1) # Gets each column from CSV file

x = my_csv[:,0] y = my_csv[:,1]

# Generates plot plt.scatter(x,y)

#Least-squares polynomial fitting z = np.polyfit(x,y, 1)

p = np.poly1d(z)

print("Best fit polinomial equation: ",p) # Generates plot

plt.show()

plt.savefig('scatter_plot5.png') 48

O código está mostrado abaixo. O bloco em vermelho destaca a parte da leitura do arquivo CSV, x = my_csv[:,0] lê toda a primeira coluna (coluna zero).

(49)

Best fit polinomial equation: 2.047 x - 0.2116

49

Abaixo temos informações sobre a reta obtida pelo programa e o gráfico gerado.

(50)

Vimos anteriormente duas bibliotecas do Python, que são usadas de forma intensa em computação científica, a de gráficos (Matplotlib) e a de computação numérica (NumPy). Hoje iremos ver alguns recursos adicionais da biblioteca NumPy. Abaixo temos a página de entrada do projeto NumPy. Se você instalou o Python via pyzo, a biblioteca do NumPy já está instalada, caso contrário veja as instruções em

www.numpy.org, de como fazer a instalação.

Biblioteca NumPy

www.python.org

Página de entrada do site: http://numpy.org. Acesso em 24 de julho 2016.

(51)

A função array() cria um array a partir de uma lista. Vejamos um exemplo, o programa

numpy_ex1.py, mostrado abaixo. Criamos uma lista com os 10 primeiros elementos da

série de Fibonacci e atribuímos à variável my_list. Em seguida, usamos a função

np.array(), para criarmos um array a partir da lista my_list. Vejam que, tanto a lista

quanto o array, apresentam seus elementos indexados, e podem ser acessados individualmente, como no loop for que vem em seguida.

Ao executarmos o numpy_ex1.py, temos o resultado a seguir.

Biblioteca NumPy (função array() )

www.python.org

import numpy as np # Imports library NumPy

my_list = [1,1,2,3,5,8,13,21,34,55] # Assigns 10 elements of Fibonacci series to the list my_list my_array = np.array(my_list) # Creates an array from a list and assigns it to my_array for i in range(len(my_array)): # Loop for to show elements of array and list

print(my_list[i],my_array[i]) 1 1 1 1 2 2 3 3 5 5 8 8 13 13 21 21 34 34 55 55

Veja que não há diferença na forma de acessarmos os elementos da lista e do array. A vantagem do uso de arrays, está na possibilidade de uso das funções da biblioteca NumPy. Outra diferença que temos que

destacar, os arrays tratam sempre de elementos numéricos e de um só tipo, não podemos misturar inteiros com floats. Nas listas podemos misturar.

(52)

Já vimos a função linspace(start, stop, num), que cria um array que inicia em start e termina em stop, com um total de num números igualmente espaçados. Vejamos o código numpy_ex2.py. A linha de código my_array = np.linspace(5,10,11) indica a criação de um array com 11 elementos, que começa em 5 e termina em 10, veja que os extremos estão incluídos.

Ao executarmos o código, temos o resultado abaixo.

# Creates an array that starts at 5, finishes at 10 and has 11 elements equally spaced

my_array = np.linspace(5,10,11)

for i in range(len(my_array)): # Loop for to show elements of array print(my_array[i]) 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0 9.5 10.0

A execução gera 11 elementos, que são mostrados na tela, como os extremos estão incluídos, são inseridos 9 elementos entre 5 e 10. A condição de igual espaçamento entre os números, impõe que teremos um intervalo de 0.5 entre os números do array.

Biblioteca NumPy (função linspace() )

www.python.org

(53)

A função arange(start, stop, step, dtype=float) cria um array que inicia em start, finaliza em stop (exclusivo) e tem um passo step. Podemos selecionar o tipo dos elementos do array, com dtype = float por exemplo. O código numpy_ex3.py cria um array que inicia em 5.0 e termina em 10.0 (exclusivo), ou seja, o 10.0 não está incluído. Não é necessário explicitar a palavra chave dtype, basta que indiquemos o tipo como argumento da função arange(), como indicado na linha vermelha abaixo.

A execução de numpy_ex3.py gera o resultado abaixo.

# Creates an array that starts at 5, finishes at 10 (exclusive) and has a step of 0.5

my_array = np.arange(5,10,0.5,float)

for i in range(len(my_array)): # Loop for to show elements of array print(my_array[i]) 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0 9.5

Foram gerados 10 elementos, que são mostramos na tela, como o extremo superior (10.0) não está incluído, o último elemento do array é 9.5.

Uma observação, se o dtype não for especificado o interpretador Python infere o tipo de número a partir dos outros argumentos (start, stop, step).

Biblioteca NumPy (função arange() )

www.python.org

(54)

Podemos gerar um array só com zeros, usando-se a função zeros(num, dtype=float), que retorna um array com num zeros. Podemos especificar o tipo com dtype. Abaixo temos o código gen_zeros.py. A linha de código my_array = np.zeros(10,dtype=int) gera um array com 10 elementos, todos zeros e inteiros. Como na função arange(), não precisamos explicitar o dtype.

Ao executarmos o código, temos o resultado abaixo.

import numpy as np # Imports library NumPy # Creates an array with 10 zeros of integer type

my_array = np.zeros(10,dtype=int)

for i in range(len(my_array)): # Loop for to show elements of array print(my_array[i]) 0 0 0 0 0 0 0 0 0 0

A execução de gen_zeros.py gera 10 zeros, todos inteiros. O default da função zeros() é dtype = float.

Biblioteca NumPy (função zeros() )

www.python.org

(55)

Temos uma função da biblioteca NumPy para gerar um array de números “1”. Sem surpresas, a função é ones(num, dtype=float), que retorna um array com num números “1”. As regras da função zeros() são mantidas para a função ones().

Abaixo temos o array de “1.0” gerados e mostrados na tela.

import numpy as np # Imports library NumPy # Creates an array with 10 ones of float type

my_array = np.ones(10)

for i in range(len(my_array)): # Loop for to show elements of array print(my_array[i]) 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0

A execução de gen_ones.py gera 10 números “1”, todos do tipo float. Como para função zeros(), o default da função ones() é dtype = float.

Biblioteca NumPy (função ones() )

www.python.org

(56)

A abordagem moderna do desenho e desenvolvimento de fármacos é resultado de um processo iterativo. Em cada iteração (ciclo de desenvolvimento) espera-se que a atividade farmacológica da molécula seja aprimorada, de forma que haja uma evolução no processo (otimização da atividade farmacológica). O diagrama ao lado ilustra o ciclo. No processo iterativo a molécula é desenhada e passa para síntese. Neste ponto pode ser necessário retorno à fase de desenho, caso a síntese apresente desafios, não previstos na fase de desenho.

Quantitative Structure Activity Relationship

www.python.org

(57)

Chegando-se à fase de teste, a atividade é averiguada e os resultados relacionados à estrutura do fármaco em potencial. Neste processo podemos inserir uma fase de análise, onde elaboramos um modelo computacional, que permite que a atividade da molécula seja relacionada com sua estrutura, ou seja, um estudo da Relação Quantitativa-Estrutura-Atividade (Quantitative Structure-Activity Relationship, QSAR). Neste estudo

descritores moleculares são

relacionados à atividade da molécula, e uma análise estatística dos descritores leva a um modelo que pode ser usado para prever atividade farmacológica.

QSAR Quantitative Structure Activity Relationship

www.python.org

(58)

A abordagem de QSAR foi introduzida pelo trabalho pioneiro de Corwin Hansch na década de 1960, no seu estudo da atividade biológica de uma série de compostos relacionados estruturalmente. A atividade biológica pode ser relacionada com a estrutura molecular, a partir de equações como a descrita abaixo:

onde C é a concentração molar de um composto necessário para produzir uma dada atividade biológica, por exemplo IC₅₀, log P é o coeficiente de partição entre octanol e água,  é outro descritor molecular, como número de doadores de ligação de hidrogênio da molécula.

 







₀ ₁

log

₂

1 log

















P

C

Descritores moleculares descrevem propriedade gerais de uma dada molécula, que podem estar relacionadas com a atividade farmacológica. Por exemplo, um logP abaixo de 5 indica que a molécula tem baixa hidrofobicidade, aumentando as chances de disponibilidade oral.

Fonte da imagem:

http://www.sciencephoto.com/media/350656/enlarge

Acesso em: 24 de julho 2016.

www.python.org

(59)

Várias metodologias têm sido usadas para elaborar modelos de QSAR, sendo regressão a mais aplicada, colocada na sua forma linear, a equação de regressão tem o seguinte aspecto: y = ₀ + ₁ x

onde y é a variável dependente (a propriedade biológica a ser modelada), um exemplo de variável dependente usada em QSAR é log (1/IC₅₀). IC₅₀ é a

constante inibitória para que a

atividade biológica caia 50 %. O termo x

é a variável independente (descritor molecular), como exemplos de variáveis independentes, usadas em QSAR, temos o log P, número de ligações rotáveis, número de doadores de ligação de H etc. O ₁ é coeficiente angular da reta, ou do ponto de vista de otimização, o peso da variável x e ₀ é a constante de regressão.

Reta (em vermelho) obtida por regressão linear para um conjunto de pontos experimentais (pontos azuis).

O gráfico foi gerado com o programa Mathematica (http://demonstrations.wolfram.com/VisualizingRSquaredInSt atistics/)

www.python.org

(60)

Não é objetivo desta disciplina ir a fundo em métodos numéricos, mas a matemática necessária para entendermos a regressão linear é simples, por isso vamos ver as equações usadas no método. Nas equações abaixo, os termos entre < > indicam média aritmética. Na regressão linear os coeficientes ’s são dados pelas seguintes equações,

As linhas descritas por regressão linear passam pelo ponto médio , onde <x> e <y> são as médias das variáveis independente e dependente, respectivamente, como mostrada nas equações abaixo, N é o número de dados disponíveis (pares x,y):











  N i i N i i i

x

y

x

1 2 1 1

)

(

)

)(

(



x

y

₁ 0







)

,

(

x

y





 N i i

x

N

x

1

1 



 N i i

y

N

y

1

www.python.org

(61)

0.1 1.25 0.2 1.5 0.3 4 0.4 5.1 0.5 6.3 0.6 5 0.7 8.7 0.8 9 0.9 11 1 14 1.1 13.75 1.2 15 1.3 18 1.4 17.5 1.5 19 1.6 17 1.7 21 1.8 22.5 1.9 26 2 25.1 X Y





 N i i

x

N

x

1

1 



 N i i

y

N

y

1

1 









  N i i N i i i

x

y

x

1 2 1 1

)

(

)

)(

(



x

y

₁ 0







Vamos considerar um conjunto de 20 pontos, mostrados na tabela abaixo. Usaremos estes dados para calcular a melhor reta, a partir das equações da regressão linear. O Excel já tem uma função de regressão, usaremos o exemplo abaixo para explicitar os termos.

www.python.org

Numa abordagem algorítmica para resolução do problema, temos como primeiro passo o cálculo da média, com as equações abaixo:

Em seguida calculamos ₁, com a equação a seguir:

Por último calculamos ₀.

(62)

1,05

1







 N i i

x

N

x

035 ,

13

1







 N i i

y

N

y

x y x- <x> y-<y> (x-<x>)(y-<y>) (x-<x>)^2 0.1 1.25 -0.95 -11.785 11.19575 0.9025 0.2 1.5 -0.85 -11.535 9.80475 0.7225 0.3 4 -0.75 -9.035 6.77625 0.5625 0.4 5.1 -0.65 -7.935 5.15775 0.4225 0.5 6.3 -0.55 -6.735 3.70425 0.3025 0.6 5 -0.45 -8.035 3.61575 0.2025 0.7 8.7 -0.35 -4.335 1.51725 0.1225 0.8 9 -0.25 -4.035 1.00875 0.0625 0.9 11 -0.15 -2.035 0.30525 0.0225 1 14 -0.05 0.965 -0.04825 0.0025 1.1 13.75 0.05 0.715 0.03575 0.0025 1.2 15 0.15 1.965 0.29475 0.0225 1.3 18 0.25 4.965 1.24125 0.0625 1.4 17.5 0.35 4.465 1.56275 0.1225 1.5 19 0.45 5.965 2.68425 0.2025 1.6 17 0.55 3.965 2.18075 0.3025 1.7 21 0.65 7.965 5.17725 0.4225 1.8 22.5 0.75 9.465 7.09875 0.5625 1.9 26 0.85 12.965 11.02025 0.7225 2 25.1 0.95 12.065 11.46175 0.9025 1.05 13.035 85.795 6.65 902 , 12 65 , 6 795 , 85 ) ( ) )( ( 1 2 1 1           N i i N i i i x x y y x x



0,512 05 , 1 . 902 , 12 035 , 13 1 0       y



x



Temos a seguinte sequencia de cálculos:

1)Médias

2)Cálculo do ₁

3)Cálculo do ₀

www.python.org

(63)

0 5 10 15 20 25 30 0 0.5 1 1.5 2 2.5 Var iáv e l d e p e n d e n te Variável independente 0.1 1.25 0.2 1.5 0.3 4 0.4 5.1 0.5 6.3 0.6 5 0.7 8.7 0.8 9 0.9 11 1 14 1.1 13.75 1.2 15 1.3 18 1.4 17.5 1.5 19 1.6 17 1.7 21 1.8 22.5 1.9 26 2 25.1

y =



₁

x +



₀

y =12,902x

– 0,512

X Y

No final temos a melhor reta (equação de regressão), indicada abaixo:

Na elaboração de modelos de QSAR, normalmente temos mais de uma variável independente, o que leva ao uso de regressão linear múltipla. Outro nível de abstração do modelo de QSAR, é o uso de variáveis independentes não lineares. Tais métodos de aproximação estão disponíveis em pacotes como o Mathematica (www.wolfram.com). Além disso, podemos implementar os métodos de regressão linear, a partir da linguagem de programação Python.

www.python.org

(64)

Tanto nos modelos de QSAR, obtidos por regressão linear, como para aqueles obtidos por regressão linear múltipla, ou mesmo não linear, temos que acessar a qualidade do modelo de regressão, ou seja, a qualidade do ajuste da curva (ou reta) modelada, contra os pontos experimentais (y_i). Um dos parâmetros usados é o coeficiente de correlação quadrado (R2_{). Considere que y}

calc,i são valores calculados a partir da

equação de regressão, usando observações experimentais x_i. Assim temos os seguintes termos: soma total dos quadrados (Total Sum of Squares, TSS), soma

dos quadrados “explicada” (Explained Sum of Squares, ESS) e soma residual dos

quadrados (Residual Sum of Squares):

Que são usados para o cálculo de R2_{, como segue:}











 N i i

y

1 2

TSS











 N i calci

y

1 2 ,

ESS











 N i i calci

y

1 2 ,

RSS

TSS

RSS

1 R

2





www.python.org

(65)

x y x-<x> y-<y> ycalc,i (y-ycalc,i)^2 (y-<y>)^2 (ycalc,i-<y))^2 0.1 1.25 -0.95 -11.785 0.7782 0.22259524 138.886225 150.2291462 0.2 1.5 -0.85 -11.535 2.0684 0.32307856 133.056225 120.2663156 0.3 4 -0.75 -9.035 3.3586 0.41139396 81.631225 93.63271696 0.4 5.1 -0.65 -7.935 4.6488 0.20358144 62.964225 70.32835044 0.5 6.3 -0.55 -6.735 5.939 0.130321 45.360225 50.353216 0.6 5 -0.45 -8.035 7.2292 4.96933264 64.561225 33.70731364 0.7 8.7 -0.35 -4.335 8.5194 0.03261636 18.792225 20.39064336 0.8 9 -0.25 -4.035 9.8096 0.65545216 16.281225 10.40320516 0.9 11 -0.15 -2.035 11.0998 0.00996004 4.141225 3.74499904 1 14 -0.05 0.965 12.39 2.5921 0.931225 0.416025 1.1 13.75 0.05 0.715 13.6802 0.00487204 0.511225 0.41628304 1.2 15 0.15 1.965 14.9704 0.00087616 3.861225 3.74577316 1.3 18 0.25 4.965 16.2606 3.02551236 24.651225 10.40449536 1.4 17.5 0.35 4.465 17.5508 0.00258064 19.936225 20.39244964 1.5 19 0.45 5.965 18.841 0.025281 35.581225 33.709636 1.6 17 0.55 3.965 20.1312 9.80441344 15.721225 50.35605444 1.7 21 0.65 7.965 21.4214 0.17757796 63.441225 70.33170496 1.8 22.5 0.75 9.465 22.7116 0.04477456 89.586225 93.63658756 1.9 26 0.85 12.965 24.0018 3.99280324 168.091225 120.2707022 2 25.1 0.95 12.065 25.292 0.036864 145.564225 150.234049 1.05 13.035 26.6659868 1133.5505 1106.969667





1133,551

TSS

1 2









 N i i

y





26,66599

RSS

1 2 ,









 N i i calc i

y

9765

,

0

551 ,

1133

66599

,

26

1 TSS

RSS

1 R

2











www.python.org

(66)

O coeficiente de correlação quadrado mede a qualidade do ajuste da função teórica (equação de regressão) aos pontos experimentais. Esse índice varia de 0

a 1. O valor zero não indica correlação entre os dados. Para R2 _{igual a 1, ou próximo}

desse, temos uma equação de regressão com boa correlação como os dados experimentais. A equação de regressão obtida, no exemplo apresentado, tem excelente correlação, R2 _{= 0,9765, tal concordância pode ser vista na análise do}

gráfico, onde todos os pontos experimentais estão próximos à reta de regressão.

0 5 10 15 20 25 30 0 0.5 1 1.5 2 2.5 Var iáv e l d e p e n d e n te Variável independente

y =



₁

x +



₀

y =12,902x

– 0,512

R

2

_{= 0,9765}

www.python.org

(67)

É óbvio que sistemas biológicos, caracterizados por uma dada atividade, raramente podem ser modelados com funções lineares simples. A introdução de variáveis independentes no modelo de QSAR leva, muitas vezes, a um modelo mais robusto, onde características químicas relevantes (descritores) são considerados. Contudo, o princípio da

parcimônia deve ser adotado, ou seja,

nem sempre um modelo com mais variáveis independentes é o mais adequado para modelar a atividade biológica. Colocaremos como exemplo o uso do programa Mathematica para encontrarmos modelos matemáticos para conjuntos de dados.

Polinômio de grau 2 (-0,634408x2 _{+ 1,24534x + 0,0807008)}

usado para aproximar os cinco pontos experimentais mostrados acima.

O gráfico foi gerado com o programa Mathematica (http://demonstrations.wolfram.com/CurveFitting/)

www.python.org

(68)

A idéia básica atrás da aproximação de uma função é usar uma lista de funções matemáticas especificadas antecipadamente, e tentar encontrar uma combinação linear dessas funções dadas, de forma que essa combinação linear de funções fique o mais próximo possível do conjunto de dados. Vamos ilustrar as idéias principais com exemplos. Vamos considerar um conjunto formado pelos 19 pontos experimentais, indicados na tabela ao lado.

No próximo slide temos três funções usadas para modelar os pontos da tabela ao lado.

x y 73. 34.8105 74. 35.381 75. 35.8167 76. 40.6048 77. 47.0132 78. 42.4577 79. 43.1319 80. 37.3182 81. 33.6343 82. 28.0988 83. 28.3107 84. 29.9822 85. 27.2542 86. 33.407 87. 35.4875 88. 38.1126 89. 41.57 90. 42.1533 91. 39.5108

www.python.org

(69)

Nas figuras a seguir temos ajustes para diversas funções polinomiais.

y = -13615.6+508.522 x-6.29506 x2_{+0.0258975 x}3 _{y = -198884.+9597.83 x-173.196 x}2_{+1.38539 x}3_{-0.00414481 x}4

y = 2.82867×106_{-176099. x+4376. x}2_{-54.2556 x}3_{+0.335627 x}4_{-0.000828711 x}5

A última função (com termos até a quinta potência) é a que melhor se ajusta aos pontos experimentais.

www.python.org

Aproximação com polinômio de grau 3 Aproximação com polinômio de grau 4

(70)

Type CSV file name => data2.csv

Type polynomial equation degree => 5

Best fit polynomial equation: 5 4 3 2

-0.0005079 x + 0.2051 x - 33.05 x + 2655 x - 1.064e+05 x + 1.7e+06

70

Modificaremos o código scatter_plot5.py, para que o usuário digite o nome do arquivo CSV de entrada e o grau do polinômio, a ser aproximado aos dados de entrada. O novo programa chama-se

qsar1.py, as linhas de código estão no

próximo slide. A principal modificação, com relação ao programa anterior, foi a inclusão das funções input() para a leitura do nome do arquivo (my_input_file) e do grau do polinômio (my_deg). As modificações estão mostradas com linhas vermelhas. O gráfico gerado está na figura ao lado. O arquivo de entrada é o data2.csv. A equação polinomial está mostrada abaixo. Veja que o resultado está próximo ao obtido com o

Mathematica para o polinômio de grau 5. Programa: qsar1.py

(71)

# Reads input file name and polynomial equation degree my_input_file = input("Type CSV file name => ")

my_deg = int(input("Type polynomial equation degree => "))

# Reads CSV file

my_csv = np.genfromtxt (my_input_file, delimiter=",", skip_header = 1)

# Gets each column from CSV file x = my_csv[:,0]

y = my_csv[:,1] # Generates plot plt.scatter(x,y)

# Least-squares polynomial fitting

z = np.polyfit(x,y, my_deg)

p = np.poly1d(z)

print("\nBest fit polynomial equation: ",p) # Generates plot

plt.show()

plt.savefig('qsar1.png') 71

Programa: qsar1.py

(72)

Type CSV file name => data1.csv

Type polynomial equation degree => 1 Best fit polynomial equation:

12.9 x - 0.5116 , R^2 = 0.976475697411

72

Vimos que o coeficiente de correlação ao quadrado (R2_{) é usado para atestar a}

qualidade de um modelo obtido por regressão. A biblioteca NumPy tem a função np.corrcoef(x,y)[0,1], para o cálculo do coeficiente de correlação (R) entre os

arrays x e y. A partir deste valor, basta

elevarmos ao quadrado para obtermos R2_.

O código qsar2.py traz esta função. Se usarmos o programa qsar2.py, com o arquivo data1.csv, podemos conferir com os resultados anteriormente determinados. O gráfico está ao lado. Os resultados estão no quadro abaixo. O código está no próximo slide, com as linhas em vermelho indicando as modificações com relação ao

qsar1.py.

(73)

# Reads input file name and polynomial equation degree my_input_file = input("Type CSV file name => ")

my_deg = int(input("Type polynomial equation degree => ")) # Reads CSV file

my_csv = np.genfromtxt (my_input_file, delimiter=",", skip_header = 1) # Gets each column from CSV file

x = my_csv[:,0] y = my_csv[:,1] # Generates plot plt.scatter(x,y)

# Least-squares polynomial fitting, correlation coefficient and r-square z = np.polyfit(x,y, my_deg)

p = np.poly1d(z)

rsquare = (np.corrcoef(y,p(x))[0,1] )**2

print("\nBest fit polynomial equation: ",p,", R^2 = ",rsquare)

# Generates plot

plt.show()

plt.savefig('qsar2.png')

73

(74)

Todos os programas que estudamos até o momento eram sequências de comandos em Python, que começam sua execução do primeiro até o último comando. Tal abordagem de programação funciona bem para programas pequenos, até poucas centenas de linhas de código. Para programas maiores, tal abordagem pode causar problemas e dificultar a programação. Uma forma de superarmos tal obstáculo, é dividirmos nosso código em pedaços que executam uma determinada tarefa dentro do programa, e isolá-lo do programa principal, só chamando-o quando necessário. Esta parte do programa é o que chamamos de função. Para ilustrar o uso de funções em Python, usaremos um programa para o cálculo da sequência de Fibonacci. Esta sequência começa com o número “1”, o segundo número também é “1”, do terceiro número em diante temos a seguinte regra de cálculo, o número é o resultado da soma dos dois números anteriores na sequência, assim o terceiro número é 2. O quarto número é 5, o sexto é 8, e assim vai. Veja abaixo a lista dos 10 primeiros elementos da sequência de Fibonacci.

{1, 1, 2, 3, 5, 8, 13, 21, 55}

74

Funções em Python

(75)

Resumo

Programa para gerar a sequência de Fibonacci. O número de elementos da sequência dado pelo usuário. A sequência será gerada na função generate_Fibonacci(), que tem como parâmetro o número de elementos da sequência. O programa tem uma função para mostrar informações sobre o programa, chamada show_header(). Há uma terceira função, chamada show_list(), que mostra a sequência na tela.

Sequência de Fibonacci

Programa: fibonacci.py

75

Programa: fibonacci.py

(76)

def show_header():

"""Shows information about this program"""

print("\nProgram to calculate the Fibonacci sequence")

76

Mostraremos inicialmente cada uma das três funções do programa fibonacci.py. Na definição de uma função seguimos o seguinte formato, iniciamos com o comando def seguindo do nome da função, depois temos dois parênteses e, por último, dois pontos : .Para definirmos a função show_header(), seguimos o modelo acima, como indicado em vermelho no código abaixo.

Usamos o comando def seguido do nome da função e finalizamos a linha com : . A linha de código def show_header(): diz ao computador que o bloco de comandos a seguir é para ser usado como a função show_header(). Basicamente estamos dizendo que o bloco de comandos chama-se show_header() e, todas as vezes que chamarmos a função, todo o bloco será executado. A linha inicial e os comandos que seguem é o que chamamos definição da função. A definição da função não executa os comandos vinculados à ela, simplesmente indica que esse conjunto de comandos está vinculado à função, que pode ser chamada a partir do programa principal. Resumindo, a definição da função mostra o que será feito, quando a função for chamada, mas não executa o código.

(77)

def show_header():

"""Shows information about this program"""

print("\nProgram to calculate the Fibonacci sequence")

77

A primeira linha do bloco de comandos da função show_header() traz a docstring, que é um comentário explicando a tarefa realizada. A docstring tem que estar entre três aspas duplas. Seu uso é facultativo, mas se for usá-la, esta tem que vir logo em seguida à linha com a definição da função, e, como destacado, entre três aspas duplas. A função show_header() mostra uma mensagem na tela com a função print(). Para chamar a função show_header(), temos que programar sua chamada a partir do programa principal. Veja que os comandos, que serão executados, quando a função for chamada, estão recuados, como fazemos com blocos de comandos para loops e

ifs. O recuo identifica o bloco de comandos vinculados à função.

Assim, teremos mais para frente do código do programa principal, uma linha com

show_header(). A função show_header() não tem entradas e não retorna valores,

simplesmente mostra uma mensagem na tela ao ser chamada. A seguir temos uma função com entrada e saída.