Você está na página 1de 50

VICTOR HUGO GARCIA DE CAMPOS

ROSEVALDO DE OLIVEIRA

Computação Cientı́fica usando Python

1a Edição

Rondonópolis
Edição do Autor
2016
Sumário

Sumário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1 PRIMEIROS CONTATOS . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1 Ambientes de Desenvolvimento . . . . . . . . . . . . . . . . . . . . . . 4
1.1.1 Terminal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.1.2 Ipython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.1.3 Spyder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2 Diferenças entre Python 2.x e 3.x . . . . . . . . . . . . . . . . . . . . . 8
1.3 Importando Módulos de Bibliotecas . . . . . . . . . . . . . . . . . . . . 9
1.4 Comandos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5 Sequências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5.1 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5.2 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.6 Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.6.1 Definindo Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.7 Controle de Fluxo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.7.1 Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.7.2 If - Then - Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.7.3 Laço For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.7.4 Laço While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2 NUMPY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1 Funções Matemáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1.1 Funções Gerais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1.1.1 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.1.2 Números Complexos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.1.2.1 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.2 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.2.1 Criando Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.2.1.1 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3 Álgebra Linear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3.1 Utilizando arrays como matrizes . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3.1.1 Exercı́cios: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.3.2 Produto Escalar e Vetorial . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.3.2.1 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.3.2.2 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.4 Polinômios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.4.0.1 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.5 Estatı́stica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.5.0.1 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.5.0.2 Exercı́cios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

3 MATPLOTLIB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.1 Gráficos Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.1.1 Mudando Cores e Espessuras da linha . . . . . . . . . . . . . . . . . . . . . 35
3.2 Gráficos 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4 SYMPY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.1 O que Computação Simbólica . . . . . . . . . . . . . . . . . . . . . . . 39
4.2 Operações Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.2.1 Substituições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.2.1.1 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.2.1.2 Convertendo Strings em Expressões SymPy . . . . . . . . . . . . . . . . . . . . 41
4.2.1.3 evalf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.2.2 lambdify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.3 Simplificações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.3.1 simplify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.3.2 Funções de Simplificação Polinomial . . . . . . . . . . . . . . . . . . . . . . 43
4.3.2.1 expand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.3.2.2 factor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.3.2.3 colect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.3.2.4 apart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.3.3 Simplificaçõs Trigonométricas . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.3.3.1 trigsimp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.3.3.2 expand trig . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.4 Cálculo Diferencial e Integral . . . . . . . . . . . . . . . . . . . . . . . . 45
4.4.1 Derivadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.4.2 Integrais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4.5 Limites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5 EXERCÍCIOS DE FIXAÇÃO . . . . . . . . . . . . . . . . . . . . . . . 48

REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1 Primeiros Contatos

Python é uma linguagem de programação interpretada, orientada à objeto, de alto nı́vel


e de semântica dinâmica.[6] Possui tipagem dinâmica, é rápida,e sua simplicidade o torna
atraente e produtiva.
Possui uma infinidade de bibliotecas e hoje é uma das linguagens mais utilizadas no
mundo.
Para computação cientı́fica Python possui ótimas bibliotecas, as mais usadas são NumPy,
SciPy, Matplotlib, Pandas e Sympy. Com essas bibliotecas podemos trabalhar com cálculo
numérico, processamento de sinais, construir gráficos, trabalhar com expressões matemáticas
(Computer Algebra System), estatı́stica e muito mais.
O Python é incrivelmente amplo, existe inúmeros programas desenvolvido nele, que va-
riam desde programas de escritório à edição de imagens e vı́deo. Nosso foco serão os módulos
matemáticos e cientı́ficos, veremos que seus recursos equivalem a softwares cientı́ficos pagos,
devido ao empenho de diversos cientistas do mundo inteiro.

1.1 Ambientes de Desenvolvimento


1.1.1 Terminal
Para usuários Linux basta digitar ”python”em um terminal que aparecerá o prompt da
seção interativa >>>.
Algumas distribuições vem com python 3.x por padrão, como Arch Linux. Nesse caso
para acessar o python 2.x digite python2 no terminal.

Figura 2 – Comando python no emulador de terminal linux

Ao iniciar o python, o terminal nos mostra a versão, que no caso é a 2.7.8, versão que
trabalharemos aqui. Hoje apesar de existir python 3.x a versão 2.x continua em desenvolvi-
mento, podendo então o usuário escolher qual versão lhe agrada.
Mais a frente haverá uma explicação das principais diferenças entre as duas versões.
Não preocupe-se com os comandos a princı́pio, o objetivo aqui é diferenciar os recursos
de cada ambiente.
(a) Numpy. (b) Scipy.

(c) Matplotlib.

(d) Sympy

Figura 1 – Imagens da utilização de algumas bibliotecas do Python.


>>> 3+5
8
>>> a = 7
>>> for i in xrange (5) :
... print a * i
...
0
7
14
21
28
>>>

No terminal linux podemos utilizar alguns recursos interessantes como mostra a figura 3,
mas não são apresentados outros recursos como listas de comandos e documentação conforme
o usuário digita.

Figura 3 – Python num terminal linux.

É o mais simples terminal para utilizar o python em seções interativas.

1.1.2 Ipython
O Ipython é formidável. É muito versátil. Possui um console simples com os recursos de
um terminal.
Um console baseado em Qt com recursos de edição de texto, lista os comandos e exibe
a documentação dos comandos conforme o usuário digita, pode configurá-lo para impressão
matemática bonita via utf-8 ou latex, configurá-lo para mostrar os gráficos embutidos no
próprio console.
E o notebook que é um ambiente no navegador de internet a qual cada conjunto de
comando é separado por células, o usuário pode retornar as células anteriores para modi-
ficação, pode-se salvar o arquivo de trabalho para posterior edição, além dos outros recursos
mencionados nos consoles anteriores e muito mais.
(a) Console do Ipython. (b) Qt console do Ipython.

(c) Ipython notebook

Figura 4 – Consoles e Notebok do Ipython.


Figura 5 – Spyder - Ambiente de Desenvolvimento Cientı́fico.

1.1.3 Spyder
Spyder para computação cientı́fica, é o canivete suı́ço para o desenvolvedor python. Pos-
sui em um só programa, um console interativo, Ipython Qtconsole, editor de texto para
scripts, um explorador de documentação de bibliotecas, explorador de variáveis, explorador
de arquivos, explorador de histórico e outros recursos que aumentam a produtividade do
usuário.
Nas preferências, pode-se configurar para a importação das bibliotecas automaticamente
na inicialização, configurar atalhos, cores, diretório de trabalho, etc...

1.2 Diferenças entre Python 2.x e 3.x


Quando estudamos programação em Python, é comum nos perguntar: Qual versão do
Python devo estudar a versão 2.x ou a 3.x?
Observando as diferenças entre as duas versões, principalmente na prática, percebe-se
poucas diferenças na qual possam destacar mais eficiência em uma delas. De fato a alguns
anos atrás a versão 2.x encontrava-se com mais bibliotecas cientı́ficas disponı́veis, porém hoje
não acontece mais.
É óbvio que é possı́vel encontrar uma ou outra biblioteca disponı́vel para uma das duas
versões, porém estudando uma dela é possı́vel migrar para a outra versão sem maiores
problemas.
As principais diferenças estão principalmente no uso de parêntesis em funções como
print, IOerror, resultados de comparações utilizando string e tupla por exemplo (na versão
2.x imprime um false, enquanto que a versão 3.x imprime um erro).
Porém a mudança mais significativa para usuários que fazem uso da computação ci-
entı́fica, talvez seja da necessidade de se utilizar na versão 2.x o comando ”from future
import division, para que o resultado da divisão de números inteiros resultem no tipo de
ponto flutuante (não é necessário na versão 3.x), e algumas mudanças em algumas funções
matemáticas como por exemplo na função round, que na função 2.x arredonda sempre para
o menor número inteiro, caso que não acontece na versão 3.x (critério de arredondamento
utilizado comumente na matemática).
Recomenda-se que o iniciante escolha uma versão para começar seu estudo, e se es-
pecialize, pois encontrando a necessidade de converter seu código para outra versão, não
encontrará muita dificuldade, principalmente porque existem módulos que já fazem isso au-
tomaticamente, como py2to3.

1.3 Importando Módulos de Bibliotecas


Quando tiver um projeto, antes de qualquer código, é importante uma pesquisa nas
bibliotecas. Sempre existe algo que alguém fez para você adiantar sua programação.
Encontrando o que precisa é preciso saber as formas para a importação das classes e
funções a utilizar.

a) Podemos importar apenas o módulo.

In [1]: import math

In [2]: math . pi
Out [2]: 3 .14159 265358 9793

In [3]: math . cos ( math . radians (30) )


Out [3]: 0. 86 60 25 40 378 44 38 7

In [4]: math . sin ( math . radians (90) )


Out [4]: 1.0

b) Podemos importar módulos utilizando abreviações ou mesmo outros nomes.

In [13]: import sympy as sy

In [14]: sy . var ( ’s t ’)
Out [14]: (s , t )

In [15]: a = s **2 -4* s -9


In [16]: sy . solve (a , s )
Out [16]: [2 + sqrt (13) , - sqrt (13) + 2]

c) Podemos importar algumas funções

In [5]: from numpy import radians , sin , cos , exp

In [6]: sin ( radians (45) )


Out [6]: 0 . 70 7 1 06 7 8 11 8 6 54 7 4 6

In [7]: sin ( radians (90) )


Out [7]: 1.0

In [8]: cos ( radians (90) )


Out [8]: 6 .12323 399573 6766 e -17

In [9]: exp ( - radians (36) ) * cos ( radians (36) )


Out [9]: 0 . 43 1 6 00 9 3 19 8 9 35 2 5 7

d) Podemos importar tudo de um módulo.

In [1]: from pylab import *


...: from random import *

In [2]: x = linspace (0 ,50 ,100)

In [3]: y = randn (100) *50

In [4]: plot (x , y )
Out [4]: [ < matplotlib . lines . Line2D at 0 x7f7e940e6050 >]

In [5]: show ()

Os códigos acima geram o seguinte gráfico:


1.4 Comandos Básicos
O python possui atribuição dinâmica, devido a isso para fazer a atribuição a uma variável
basta digitar a variável, o sinal de igual ’=’, seguido do valor a qual deseja atribuir.
Os principais tipos de dados que utilizaremos nesta seção são: string, integer, float, list,
tuple, dict.
Ao instalar o Python há alguns módulos que já vem por padrão. Vamos fazer alguns
testes como calculadora:

>>> 7+8
15
>>> (1+7 j ) +(3 -8 j )
(4 -1 j )
>>> 2**2
4
>>> 2 -5
-3
>>> 3**(0.5)
1.732050 80 75 68 87 72

Para usar funções e constantes matemáticas podemos usar o módulo math, para isso o
importamos da seguinte maneira:

>>> import math


>>> math . sin ( math . pi *3/2)
-1.0
>>> math . sin ( math . pi *3/6)
1.0
>>> math . sin ( math . pi *3/16)
0.555570 23 30 19 60 22
>>> math . cos ( math . pi ) **2 + math . sin ( math . pi ) **2
1.0

Usando a função dir podemos podemos ver o diretório de objetos disponı́veis para o
módulo.

>>> dir ( math )


[ ’ __doc__ ’ , ’ __file__ ’ , ’ __name__ ’ , ’ __package__ ’ , ’ acos ’ , ’ acosh
’ , ’ asin ’ , ’ asinh ’ , ’ atan ’ , ’ atan2 ’ , ’ atanh ’ , ’ ceil ’ , ’
copysign ’ , ’ cos ’ , ’ cosh ’ , ’ degrees ’ , ’e ’ , ’ erf ’ , ’ erfc ’ , ’ exp ’
, ’ expm1 ’ , ’ fabs ’ , ’ factorial ’ , ’ floor ’ , ’ fmod ’ , ’ frexp ’ , ’
fsum ’ , ’ gamma ’ , ’ hypot ’ , ’ isinf ’ , ’ isnan ’ , ’ ldexp ’ , ’ lgamma ’ ,
’ log ’ , ’ log10 ’ , ’ log1p ’ , ’ modf ’ , ’ pi ’ , ’ pow ’ , ’ radians ’ , ’ sin ’
, ’ sinh ’ , ’ sqrt ’ , ’ tan ’ , ’ tanh ’ , ’ trunc ’]

Com o sinal ” ” utilizamos o último resultado calculado.

>>> # Aluguel de um carro


...
>>> val_in = 40
>>> taxa = 1.25
>>> km_perc = 120
>>> taxa * km_perc
150.0
>>> _ + val_in
190.0

No Python a tipagem das variáveis é dinâmica, portanto, é importante atentar para a


forma na qual irá atribuir valores para as variáveis. Na dúvida use a função type( ).

>>> a = 8
>>> b = 5
>>> a / b
1
>>> type ( a )
< type ’ int ’ >
>>> type ( b )
< type ’ int ’ >
>>> a = 8.
>>> b = 5.
>>> a / b
1.6
>>> type ( a )
< type ’ float ’ >
>>> type ( b )
< type ’ float ’ >

A situação acima mostrada pode causar confusão a princı́pio, porém atribuindo as variáveis
corretamente como mostrado acima ( a=8. , b=5.), obterá o resultado desejado. Neste caso
o ponto ”. ” fará com que o python interprete como tipo de ponto flutuante, sem o ponto
interpretará como inteiro.
Se precisar converter uma variável para inteiro basta usar a função int( ).
Pode também ser conveniente converter um inteiro em ponto flutuante usando a função
float( ).
A função round( ) é utilizado para arredondar o valor já que int( ) pega apenas o inteiro
do valor.
Atribuindo dados entre aspas ‘ ‘, estará avisando ao python que o dado a atribuir é uma
string.
Observe o exemplo abaixo:

>>> a = 3.5
>>> x = int ( a )
>>> type ( x )
< type ’ int ’ >
>>> x
3
>>> x = int ( round ( a ) )
>>> x
4
>>> b = ’8 ’
>>> type ( b )
< type ’ str ’ >
>>> y = float ( b )
>>> y
8.0

Assim como outras linguagens de programação o inteiro possui um valor máximo, o


módulo sys nos informa este valor como a função sys.maxint. Acima deste valor é caracte-
rizado o typo ”long”. Observe:
>>> import sys
>>> sys . maxint
2147483647
>>> type ( sys . maxint )
< type ’ int ’ >
>>> x = sys . maxint + 1
>>> x
2147483648 L
>>> type ( x )
< type ’ long ’ >

1.5 Sequências
Strings, listas e tuplas, são sequências. Elas podem ser indexados e divididos.
Tuplas e strings são imutáveis. Isso significa que não podemos mudar individualmente
elementos de uma tupla e nem caracteres de uma string. Já listas são mutáveis.
A tabela abaixo apresenta alguns comandos de sequências:

a[i] retorna o conteúdo da posição i


a[i : j] retorna os elementos i até j − 1
len( a) retorna o número de elementos da sequência
min( a) retorna o menor valor na sequência
max( a) retorna o maior valor na sequência
x in a retorna true se x ∈ a sequência a
a + b concatena a e b
n ∗ a cria n cópias da sequência a

Tabela 1 – Alguns comandos úteis para sequências.

1.5.1 Strings
Strings são ( imutáveis) sequências de caracteres. Uma string pode ser definida usando
aspas simples, dupla ou tripla.
Utiliza-se ’ ’, para atribuir a variável uma string vazia.
O número de caracteres de uma string é obtida pelo comando len( ).
Como qualquer tipo de sequência em python é válido os comandos na tabela 1. Observe:

>>> x = ’ teste ’
>>> type ( x )
< type ’ str ’ >
>>> y = ’ este e um ’
>>> z = y + x
>>> z
’ este e um teste ’
>>> k = ’ ’
>>> k
’’
>>> len ( k )
0
>>> len ( z )
15
>>> z [2]
’t ’
>>> z [10:14]
’ test ’
>>> max ( z )
’u ’
>>> min ( z )
’ ’

Strings possui inúmeras funções úteis. Pode-se encontrar usando o comando dir( ) e help.
Não será discutido muitas funções em strings, pois não é o objetivo deste trabalho este
foco. Porém algumas funções são úteis, como: upper( ), split( ), join( ). Observe:

>>> a = ’ Isto e uma sequencia ’


>>> a = a . upper ()
>>> a
’ ISTO E UMA SEQUENCIA ’
>>> a . split ()
[ ’ ISTO ’ , ’E ’ , ’ UMA ’ , ’ SEQUENCIA ’]
>>> a = " O cachorro esta faminto . O gato e chato . A cobra e
perigosa "
>>> a . split ( " . " )
[ ’O cachorro esta faminto ’ , ’ O gato e chato ’ , ’ A cobra e
perigosa ’]
>>> a = a . split ( " . " )
>>> b = " . " . join ( a )
>>> b
’O cachorro esta faminto . O gato e chato . A cobra e perigosa ’

1.5.2 Listas
Listas são sequências mutáveis de objetos. Atribuı́mos uma lista a uma variável entre
colchetes, separando cada objeto por vı́rgula. Os objetos dentro de uma lista, podem ser de
qualquer tipo. Pode-se gerar uma lista vazia apenas por [ ].
Abaixo alguns exemplos:

>>> a = [ ’ abelha ’ , 43.98 , [1 ,2 ,3 ,4]]


>>> a
[ ’ abelha ’ , 43.98 , [1 , 2 , 3 , 4]]
>>> len ( a )
3
>>> len ( a [2])
4
>>> type ( a )
< type ’ list ’ >
>>> type ( a [2])
< type ’ list ’ >
>>> type ( a [0])
< type ’ str ’ >
>>> type ( a [1])
< type ’ float ’ >

As operações da tabela 1 são muito úteis:

>>> a = [0 ,1 ,2 ,3 ,4 ,5 ,6]
>>> b = [7 ,8 ,9]
>>> a + b
[0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9]
>>> c = a [5:] + b
>>> c
[5 , 6 , 7 , 8 , 9]
>>> max ( b )
9
>>> min ( b )
7
>>> 6 in b
False
>>> 6 in a
True

Como listas são mutáveis, podemos alterar objetos nela individualmente:

>>> a = [1 ,2 ,3 ,4 ,5]
>>> a [0] = ’u ’
>>> a
[ ’u ’ , 2 , 3 , 4 , 5]
>>> a [4] = ’ python ’
>>> a
[ ’u ’ , 2 , 3 , 4 , ’ python ’]

Pode-se adicionar objetos ao fim de uma lista com o comando append( ), e remover o
primeiro objeto indicado com remove( ):

>>> a = [53 , 26 , -78 , 26]


>>> a . remove (26)
>>> a
[53 , -78 , 26]
>>> a . append (12)
>>> a
[53 , -78 , 26 , 12]

Um comando muito utilizado para gerar listas de inteiros é o range( ). Veremos adiante
que é muito útil para laços de repetição.
Quando digitamos apenas range( n), na qual n é um número inteiro qualquer, ele gera
uma lista de inteiros começando do 0 até n − 1 com incremento 1.
Com o range, também podemos gerar listas começando com m, terminado em n − 1, com
incremento i, com a sintaxe: range( n,m,i).
Se não indicarmos o incremento, o comando range assumirá 1.
Exemplos:

>>> range (3)


[0 , 1 , 2]
>>> range (3 ,9)
[3 , 4 , 5 , 6 , 7 , 8]
>>> range (3 ,9 ,2)
[3 , 5 , 7]
>>> range (9 ,3 , -1)
[9 , 8 , 7 , 6 , 5 , 4]
>>> range (9 ,3 , -2)
[9 , 7 , 5]

1.6 Funções
O significado de função na matemática e na programação possui significados diferen-
tes. Na programação significa uma nomeada sequência de operações que executa uma com-
putação.
Um exemplo é a função sqrt( ) do módulo math, a qual computa a raiz quadrada do
argumento inserido entre parêntesis.

>>> from math import *


>>> sqrt (4)
2.0
>>> sqrt (9)
3.0
>>> sqrt (5)
2.23606797749979

1.6.1 Definindo Funções


As Funções nos permite agrupar várias declarações em um bloco lógico.
Abaixo segue um modelo de definição de variáveis:

def minha_funcao ( arg_1 , arg_2 , ... , arg_n ) :


’’’ Documentacao opcional ’’’
# Implementacao da funcao
return

Exemplo 1) : Calcule f ( x, y) = x2 − 4 y 2 − 9, para

a) x=15 e y=-2

b) x=-20 e y=10

c) x=-8 e y=5

>>> def f (x , y ) :
... return x **2 - 4* y **2 - 9
...
>>> f (15 , -2)
200
>>> f ( -20 , 10)
-9
>>> f ( -8 , 5)
-45

Exemplo 2: Defina funções para imprimir uma string centralizado entre asterisco.
>>> def r et or na r_ as te ri sc o ( n ) :
... return n * " * "
...
>>> def imp_string_ast ( string ) :
... comp_linha = 46
... ast_str = re to rn ar _a ste ri sc o (( comp_linha - len ( string ) ) /2)
... print ast_str + string + ast_str
...
>>> imp_string_ast ( ’ Hello World ’)
********* ****** ** Hello World *** ****** ****** **

1.7 Controle de Fluxo


1.7.1 Condicionais
Os valores True e False são palavras reservadas do python.
Pode-se operar essas duas palavras reservadas usando lógica booleana. Abaixo segue
exemplos com os operadores and , not e or .

>>> True and True


True
>>> False and True
False
>>> a = True
>>> b = False
>>> c = a and b
>>> c
False
>>> True or False
True
>>> not False
True
>>> not True
False

Em código computacional frequentemente precisamos calcular expressões que exijam res-


postas em True e False.
Exemplos:
>>> x = 30
>>> x > 15
True
>>> x > 42
False
>>> x == 30
True
>>> x == 42
False
>>> not x == 42
True
>>> x != 42
True
>>> x >= 30
True

1.7.2 If - Then - Else


A declaração if permite a execução de código condicional. Por exemplo:

>>> a = 17
>>> if a == 0:
... print " a é zero "
... elif a < 0:
... print " a é negativo "
... else :
... print " a é positivo "
...
a é positivo

O a declaração if pode também ter uma parte else, a qual é executado quando a condição
anterior não é satisfeita.

>>> a = 34
>>> if a > 0:
... print " a é positivo "
... else :
... print " a é negativo "
...
a é positivo
Finalmente, tem o elif a qual permite a análise de vários condicionais no mesmo bloco.

>>> a = 17
>>> if a == 0:
... print " a é zero "
... elif a < 0:
... print " a é negativo "
... else :
... print " a é positivo "
...
a é positivo

1.7.3 Laço For


O laço for permite iteração sob uma sequência ( podendo ser, por exemplo uma lista ou
string). Segue um exemplo:

>>> for animal in [ ’ animal ’ , ’ gato ’ , ’ rato ’ ]:


... print animal , animal . upper ()
...
animal ANIMAL
gato GATO
rato RATO

Junto com o comando range( ), pode-se iterar sobre listas de incrementos inteiros.

>>> for i in range (5 ,10) :


... print i
...
5
6
7
8
9

1.7.4 Laço While


O laço while permite repetir uma operação enquanto uma condição for verdadeira.
Exemplo 1)
Supondo que gostarı́amos de saber quantos anos devemos esperar para obter R$200, 00
de juros a uma taxa de 5% investindo R$100, 00 numa conta poupança.
>>> dinheiro = 100
>>> taxa = 0.05
>>> anos = 0
>>> while dinheiro < 200:
... dinheiro += dinheiro * taxa
... anos = anos + 1
...
>>> print " Precisamos esperar " , anos , " anos para obter R$ " ,
dinheiro , " de juros . "
Precisamos esperar 15 anos para obter R$ 207.892817941 de
juros .

Exemplo 2)
Faça um programa para calcular o fatorial de um número inteiro positivo. Calcule o
fatorial do número 15.

>>> n = input ( ’ Digite um únmero inteiro positivo : ’)


Digite um únmero inteiro positivo : 15
>>> c = n
>>> res = 1
>>> while c > 1:
... res = res * c
... c = c - 1
...
>>> print n , ’! = ’ ,res , ’ . ’
15 ! = 1307674368000 .
2 Numpy

2.1 Funções Matemáticas


2.1.1 Funções Gerais
A biblioteca numpy fornece as principais funções matemáticas ao python. Sua nomecla-
tura é auto-explicativa. Abaixo segue uma tabela com as principais funções.

sin( x ) arctan2( x )
cos( x ) degrees( x )
tan( x ) radians( x )
arcsin( x ) unwrap( x )
arccos( x ) deg2rad( x )
arctan( x ) rad2deg( x )
hypot( x1 , x2 ) sinh( x )
cosh( x1 ) tanh( x )
arcsinh( x ) arccos( x )
arctanh( x ) exp( x )
log( x ) log10( x )
log2( x ) sqrt( x )

Tabela 2 – Funções trigonométricas.

Exemplos:

>>> x = 2.* pi /3
>>> sin ( x )
0.86602 5 4 03 7 8 44 3 8 71
>>> cos ( x )
-0.49999999999999978
>>> sin ( x ) **2 + cos ( x ) **2
0.999999 9 9 99 9 9 99 9 8 9
>>> log (4)
1.386294 36 11 19 89 06
>>> log ( exp (1) )
1.0
>>> log10 (10)
1.0
>>> log2 (2)
1.0
>>> hypot (3 ,4)
5.0
2.1.1.1 Exercı́cios

1. Calcule as seguintes funções para os valores (−11, 43, 8976, 0.00036).

a) sin(x) ex/2
cos(x)
b) ln(x) sin2 (x) + log2 (x)

c) ex log10 (x)

2. Faça uma função em python para resolver a Equação de Colebrook descrita abaixo,
sabendo que 0 < f ≤ 1, e que a função deverá ter como argumento mı́nimo as variáveis

D
, Re e f ( def Colebrook(ed, Re, f ))
 
1 /D 2, 51
√ = −2 log + √
f 3, 7 Re f

Teste sua solução. Para D
= 0.000375 e Re = 1, 37 104 , temos f = 0, 0291

2.1.2 Números Complexos


Para gerar um número complexo basta evidenciar o número imaginário acompanhando-o
do ”j”sem nenhum operando entre eles. Com isso pode-se efetuar operações básicas com as
operações convencionais. Vejam:

>>> b = -5 -2 j
>>> a + b
( -2+4 j )
>>> a / b
( -0.9310344827586208 -0.8275862068965517 j )
>>> a * b
( -3 -36 j )

Abaixo é mostrado algumas funções comumente utilizadas com números complexos.


angle( z ) real( z ) imag( z ) conj( z )

Tabela 3 – Funções complexas.

>>> c = [a , b ]
>>> c
[(3+6 j ) , ( -5 -2 j ) ]
>>> angle ( c )
array ([ 1.10714872 , -2.76108628])
>>> degrees ( angle ( c ) )
array ([ 63.43494882 , -158.19859051])
>>> real ( a ) + real ( b )
-2.0
>>> imag ( a ) + imag ( b )
4.0
>>> conj ( a )
(3 -6 j )

2.1.2.1 Exercı́cios

1. Resolva as seguintes operações:

a) (2 - 5i) + (-3 + 3i)


(5 − 2i)
b) − (2 − 4i).(5 − 2i)
(5 − 6i)
(3 − 6i)2 + (5 + 4i)3
c)
(2 + 5i)2
2. Faça uma função que retorne um número complexo na forma polar. Esta função deverá
retornar um array de dois elementos ao qual o primeiro deverá ser o módulo e o segundo
seu ângulo em graus.

2.2 Arrays
Array é um tipo de conjunto de dados que comporta-se de forma semelhante a listas,
exceto pelo fato de que os elementos devem ser do mesmo tipo.
Exemplos:

>>> a = array ([[ -1 ,2] ,[3. ,4]])


>>> b = array ([[ -1 ,2] ,[3. , ’a ’ ]])
>>> b
array ([[ ’ -1 ’ , ’2 ’] ,
[ ’ 3.0 ’ , ’a ’]] ,
dtype = ’| S3 ’)
>>> a
array ([[ -1. , 2.] ,
[ 3. , 4.]])
>>> type ( a [1 ,1])
< type ’ numpy . float64 ’ >
>>> type ( b [1 ,1])
< type ’ numpy . string_ ’ >
2.2.1 Criando Arrays
Existem inúmeras formas de se criar um array. Mas a forma mais comum é a conversão
um uma lista ou tupla em array.
Exemplos:

>>> a = array ([1 ,6 ,4 ,7 ,5 ,3])


>>> a
array ([1 , 6 , 4 , 7 , 5 , 3])
>>> b = array ((1 ,4 ,3 ,5 ,6 ,7 ,8) )
>>> b
array ([1 , 4 , 3 , 5 , 6 , 7 , 8])
>>> c = array ([[ -2 ,3] ,[0 ,4]])
>>> c
array ([[ -2 , 3] ,
[ 0, 4]])

Porém existem funções do numpy no qual retornam arrays. As principais estão descritas
na tabela abaixo:
empty( (l,c) ) Cria uma matriz vazia com as dimensões (l,c)
zeros( (l,c) ) Cria uma matriz de zeros com as dimensões (l,c)
ones( (l,c) ) Cria uma matriz de elementos de valor 1 com as dimensões (l,c)
eye( n ) Retorna uma matriz identidade de ordem n
identity( n ) Retorna uma matriz identidade de ordem n

Tabela 4 – Funções com Matrizes.

Exemplos:

>>> empty ((4 ,4) )


array ([[ 6.94885134 e -310 , 1.52578222 e -316 , 6.94884893 e -310 ,
6.94885170 e -310] ,
[ 6.94885174 e -310 , 6.94884729 e -310 , 6.94885171 e -310 ,
1.66047005 e -316] ,
[ 6.94884729 e -310 , 6.94885173 e -310 , 6.94885170 e -310 ,
6.94885170 e -310] ,
[ 6.94885170 e -310 , 6.94885173 e -310 , 6.94884858 e -310 ,
6.94885171 e -310]])
>>> ones ((4 ,4) )
array ([[ 1. , 1. , 1. , 1.] ,
[ 1. , 1. , 1. , 1.] ,
[ 1. , 1. , 1. , 1.] ,
[ 1. , 1. , 1. , 1.]])
>>> identity (4)
array ([[ 1. , 0. , 0. , 0.] ,
[ 0. , 1. , 0. , 0.] ,
[ 0. , 0. , 1. , 0.] ,
[ 0. , 0. , 0. , 1.]])
>>> eye (4)
array ([[ 1. , 0. , 0. , 0.] ,
[ 0. , 1. , 0. , 0.] ,
[ 0. , 0. , 1. , 0.] ,
[ 0. , 0. , 0. , 1.]])
>>> a = zeros ((4 ,4) )
>>> a
array ([[ 0. , 0. , 0. , 0.] ,
[ 0. , 0. , 0. , 0.] ,
[ 0. , 0. , 0. , 0.] ,
[ 0. , 0. , 0. , 0.]])
>>> for i in range (4) :
... for j in range (4) :
... if i == j :
... a [i , j ]=3
... else :
... a [i , j ]=1
...
>>> a
array ([[ 3. , 1. , 1. , 1.] ,
[ 1. , 3. , 1. , 1.] ,
[ 1. , 1. , 3. , 1.] ,
[ 1. , 1. , 1. , 3.]])

2.2.1.1 Exercı́cios

1. Crie um array (10,10), com a seguinte condição:



 a[i, j] = 5, i > j

a[i, j] = 10, i < j

a[1, j] = 0, i = j

2.3 Álgebra Linear


2.3.1 Utilizando arrays como matrizes
Pode-se utilizar um array como matriz matemática, algumas de suas operações são des-
critas na tabela abaixo:
linalg.det(a) Calcula o determinante de um array
dot( x, y ) retorna o produto matricial entre x e y
linalg.inv( a ) retorna a matriz inversa de a
transpose( a ) retorna a matriz transposta de a

Tabela 5 – Funções comuns para operações com matrizes matemáticas.

Com o comando matrix(a) onde a é uma sequência como lista e tuplas, atribui-se ao objeto
o tipo matrix ao qual pode-se fazer operações matriciais com os operadores convencionais.

>>> a = (0 -15) * random . random_sample ((4 ,4) ) + 15 # gera array com


dados aleatorios
>>> a
array ([[ 14.49042525 , 2.93107736 , 10.78718351 , 5.62335196] ,
[ 14.11931459 , 6.80130463 , 6.11838823 , 13.31783477] ,
[ 13.39207532 , 11.12517229 , 5.85024642 , 6.47237741] ,
[ 5.3987344 , 8.87055273 , 7.63533484 , 0.16405977]])
>>> linalg . inv ( a )
array ([[ 0.0801668 , -0.1144587 , 0.1697062 , -0.15157086] ,
[ -0.08134552 , 0.00861623 , 0.05120213 , 0.06878894] ,
[ 0.03914155 , 0.06746016 , -0.17679747 , 0.15707683] ,
[ -0.06143099 , 0.16104189 , -0.12484469 , 0.05339945]])
>>> transpose ( a )
array ([[ 14.49042525 , 14.11931459 , 13.39207532 , 5.3987344 ] ,
[ 2.93107736 , 6.80130463 , 11.12517229 , 8.87055273] ,
[ 10.78718351 , 6.11838823 , 5.85024642 , 7.63533484] ,
[ 5.62335196 , 13.31783477 , 6.47237741 , 0.16405977]])
>>> b = matrix ( a )
>>> b ** -1
matrix ([[ 0.0801668 , -0.1144587 , 0.1697062 , -0.15157086] ,
[ -0.08134552 , 0.00861623 , 0.05120213 , 0.06878894] ,
[ 0.03914155 , 0.06746016 , -0.17679747 , 0.15707683] ,
[ -0.06143099 , 0.16104189 , -0.12484469 , 0.05339945]])
>>> b . T
matrix ([[ 14.49042525 , 14.11931459 , 13.39207532 , 5.3987344 ] ,
[ 2.93107736 , 6.80130463 , 11.12517229 , 8.87055273] ,
[ 10.78718351 , 6.11838823 , 5.85024642 , 7.63533484] ,
[ 5.62335196 , 13.31783477 , 6.47237741 ,
0.16405977]])

2.3.1.1 Exercı́cios:

1. Resolva o sistema de equações abaixo, sabendo que R X = Y =⇒ X = R−1 Y , onde


R é a matriz dos coeficientes das equações e Y é a matriz formada pelos números após
a igualdade.

−5x − 2y + 12z − w = −9
x + 3y − 2z + 4w = 10
−x − y − z = −7
3x − 3y + 7z + 9q = −6

2. Sabendo que o comando (a−b)∗random sample((l,c)) + b gera um array com dimensões


(l,c), de dados aleatórios num intervalo de a até b. Encontre a matriz inversa de um
array (1000,1000) de dados aleatórios obtidos num intervalo de 0 à 50000.

2.3.2 Produto Escalar e Vetorial


Podemos através dos arrays fazer a representação de vetores e efetuar produto escalar e
vetorial entre eles. Os comandos estão na tabela abaixo:
vdot( v,w ) Retorna o produto escalar dos vetores v e w
cross( v,w ) Retorna o produto vetorial dos vetores v e w

Tabela 6 – Funções de álgebra vetorial.

2.3.2.1 Exemplos

>>> u = array ([1 ,3 , -7])


>>> v = array ([10 ,7 ,2])
>>> w = array ([ -2 ,3 ,5])
>>> vdot (u , v )
17
>>> vdot (u , w )
-28
>>> cross (w , u )
array ([ -36 , -9 , -9])
>>> cross (v , u )
array ([ -55 , 72 , 23])

2.3.2.2 Exercı́cios

1. Resolva os produtos abaixo:

u = −1ı̂ − 4̂ − 3k̂


v = 3ı̂ + 7̂ − 2k̂
w = −12ı̂ − 2̂ + 5k̂
a) v × w
b) w · v
c) (v × w) · u

2. Faça duas funções chamadas modulo(v) e angulo(v), para retornar respectivamente o


módulo e o ângulo de um vetor ’v’.

2.4 Polinômios
O módulo polinomial do numpy provê a capacidade de trabalhar com polinômios. Algu-
mas funções deste módulo são mostradas na tabela abaixo:

poly1d( c ou r ) Classe polinomial


polyval( p,x ) Calcula a função polinomial ao valor x
poly( seq de zeros ) Encontra os coeficientes do polinômio com dada sequência de raı́zes
roots( p ) Retorna as raı́zes do polinômio dado os coeficientes p
polyder( p,n ) Retorna a n-derivada do polinômio p
polyint( p,n ) Retorna a n-integral do polinômio p
polyadd( a1,a2 ) Retorna a soma de dois polinômios
polydiv( a1,a2 ) Retorna a divisão de dois polinômios
polymul( a1,a2 ) Retorna a multiplicação de dois polinômios
polysub( a1,a2 ) Retorna a subtração de dois polinômios
polyfit( x,y,n ) fita os dados em x e y com polinômio de grau n

Tabela 7 – Funções polinomiais.

2.4.0.1 Exemplos

>>> y = poly1d ([1 , -3 ,4 ,9])


>>> y (2)
13
>>> y ( -5)
-211
>>> print y
3 2
1 x - 3 x + 4 x + 9
>>> roots ( y )
array ([ 2 . 0 3 7 1 7 0 3 8 + 2 . 0 5 6 0 0 7 5 8 j , 2.03717038 -2.05600758 j ,
-1.07434076+0. j ])
>>> y . r
array ([ 2 . 0 3 7 1 7 0 3 8 + 2 . 0 5 6 0 0 7 5 8 j , 2.03717038 -2.05600758 j ,
-1.07434076+0. j ])
>>> w = poly ([3 , -2 ,1 ,6])
>>> print w
[ 1 -8 7 36 -36]
>>> w = poly1d ( w )
>>> print w
4 3 2
1 x - 8 x + 7 x + 36 x - 36
>>> polydiv (w , y )
( poly1d ([ 1. , -5.]) , poly1d ([ -12. , 47. , 9.]) )
>>> polymul (w , y )
poly1d ([ 1, -11 , 35 , -8 , -188 , 315 , 180 , -324])
>>> polyder ( y )
poly1d ([ 3 , -6 , 4])
>>> polyint ( y )
poly1d ([ 0.25 , -1. , 2. , 9. , 0. ])

2.5 Estatı́stica
O numpy fornece as seguintes funções para estatı́stica.

amin( a ) Retorna o menor valor de um array ou em torno de um eixo


amax( a ) Retorna o valor máximo de um array ou em torno de um eixo
nanmin( a ) Retorna o valor mı́nimo de um array ou em torno de um eixo ignorando qualquer NANs
nanmax( a ) Retorna o valor máximo de um array ou em torno de um eixo ignorando qualquer NANs
ptp( a ) Intervalo de valores (máx - mı́n) em torno de um eixo
percentile( a,q ) Calcula a ordem percentual dos dados num eixo especificado
average( a ) Calcula a média ponderada num array ou num eixo especificado
mean( a ) calcula a média aritmética de um array ou num eiso especificado
median( a ) Retorna a mediana de um array ou num eixo especificado
std( a ) Calcula o desvio padrão de um array ou num eixo especificado
var( a ) Calcula a variância de um array ou num eixo especificado
corrcoef( x ) Calcula o coeficiente de correlação
correlate( x,v ) Correlação cruzada de duas sequências unidimensionais
cov( m ) Estima a matriz de covariância, fornecido dados
histogram( a ) Retorna o histograma de um conjunto de dados

Tabela 8 – Funções para estatı́stica.

Porém, acaso necessitar de algo mais sofisticado, o python possui bibliotecas especializa-
das em estatı́stica como RPy e Pandas.

2.5.0.1 Exemplos

>>> x = (0 -100) * random . random_sample (50) + 100


>>> x
array ([ 70.74907985 , 85.81978003 , 26.2201741 , 58.25684684 ,
16.98377835 , 22.37007274 , 99.35857993 , 37.34684867 ,
51.8556086 , 96.03281659 , 73.20163177 , 65.26866548 ,
44.36005051 , 6.97549693 , 55.09369156 , 90.94858756 ,
39.12069946 , 60.26148999 , 99.45753485 , 80.89664363 ,
45.39066115 , 34.28043582 , 23.34374594 , 85.76107614 ,
58.06725533 , 63.61498366 , 32.87844399 , 55.18819449 ,
35.74747921 , 13.86461598 , 85.54735216 , 69.40562517 ,
58.10182778 , 65.55740479 , 76.13031215 , 94.33315092 ,
66.9845373 , 42.09990161 , 20.31191965 , 25.74580836 ,
95.32082476 , 81.28656706 , 14.0276794 , 33.693738 ,
74.06792647 , 89.81875148 , 80.53856131 , 59.37984954 ,
44.65620388 , 89.65495061])
>>> amax ( x )
99.45753 48 53 18 38 44
>>> amin ( x )
6.975496 93 43 13 86 69
>>> ptp ( x )
92.48203 79 18 86 99 77
>>> mean ( x )
57.90755 72 31 45 77 02
>>> median ( x )
58.81834 81 86 40 93 95
>>> std ( x )
26.04130 02 24 56 29 74

2.5.0.2 Exercı́cios

1. Sabendo que o comando (a−b)∗random sample((l,c)) + b gera um array com dimensões


(l,c), de dados aleatórios num intervalo de a até b. Obtenha um array com 500 dados
aleatórios distribuı́dos de 0 à 10000 e calcule a média aritmética, a variância e seu
desvio padrão.
3 Matplotlib

Matplotlib é uma biblioteca para plotagem de gráficos. Provavelmente uma das bibli-
otecas mais utilizadas do python no meio cientı́fico, devido a gráficos com qualidade de
publicação e muita versatilidade para produzir imagens de diferentes extensões.
Um exemplo de visualização de dados pode ser observado pelo último exemplo dado na
seção anterior. Vimos um algoritmo para fitar uma curva polinomial obtido através dos
dados em x e y dos pontos a fitar. Mas afinal como ficará o gráfico desta função? observem:

>>> import numpy as N


>>> dados_x = N . array ([0 , 1 , 2 , 3 , 4 , 5])
>>> dados_y = N . array ([0. , 0.8 , 0.9 , 0.1 , -0.8 , -1.])
>>> z = N . polyfit ( dados_x , dados_y , 3)
>>> p = N . poly1d ( z )
>>> p
poly1d ([ 0.08703704 , -0.81349206 , 1.69312169 , -0.03968254])
>>> print p
3 2
0.08704 x - 0.8135 x + 1.693 x - 0.03968
>>> xs = N . arange (0 ,5 ,0.1)
>>> ys = p ( xs )
>>> import pylab as pl
>>> pl . plot ( dados_x , dados_y , ’o ’ , label = ’ dados ’)
[ < matplotlib . lines . Line2D object at 0 x2a74f50 >]
>>> pl . plot ( xs , ys , label = ’ curva fitada ’)
[ < matplotlib . lines . Line2D object at 0 x2a79210 >]
>>> pl . xlabel ( ’x ’)
< matplotlib . text . Text object at 0 x2787250 >
>>> pl . ylabel ( ’y ’)
< matplotlib . text . Text object at 0 x2781c90 >
>>> pl . legend ()
>>> pl . show ()
1.0
dados
curva fitada
0.5

0.0

0.5

1.0

1.5
0 1 2 3 4 5
y

Figura 6 – Gráfico exemplo polyfit( x, y, n )

A partir de agora vamos estudar as ferramentas de plotagem de gráficos providos pela


biblioteca matplotlib, e então conseguir entender os comandos acima, para aplicá-las em
outras situações.

3.1 Gráficos Simples


Aqui vamos começar a plotar uma função sin e cos, iniciando pela configuração padrão e
enriquecendo passo a passo, até obter um gráfico com inúmeros recursos.
Primeiramente vamos construir os dados através de vetores na qual aprendemos um pouco
na seção numpy :

>>> import numpy as np


>>> X = np.linspace( -np.pi , np.pi , 256 , endpoint=True )
>>> C , S = np.cos( X ) , np.sin( X )

A seguir importamos o módulo pylab para gerar e mostrar o gráfico, com os comandos
plot( ) e show( ).

>>> import pylab as pl


>>> pl.plot( X , C )
[<matplotlib.lines.Line2D object at 0xa1ab1ec>]
>>> pl.plot( X , S )
[<matplotlib.lines.Line2D object at 0x9568b0c>]
>>> pl.show( )

Gerando o seguinte gráfico:


1.0

0.5

0.0

0.5

1.0 4 3 2 1 0 1 2 3 4

Figura 7 – Gráfico sin( x) e cos( x).

3.1.1 Mudando Cores e Espessuras da linha


Obtemos então as funções cos( x) e sin( x) com as cores respectivamente azul e vermelho,
neste próximo passo vamos alterar a coloração, aumentar a espessura da linha de ambas e
alterar as dimensões da figura deixando-a mais horizontal.

>>> pl.figure( figsize = ( 10 , 6 ) , dpi = 80 )


<matplotlib.figure.Figure object at 0xb7648aec>
>>> pl.plot( X , S , color = ’green’ , linewidth = 2.5 , linestyle = ” - ” )
[<matplotlib.lines.Line2D object at 0x9fb85cc>]
>>> pl.plot( X , C , color = ’red’ , linewidth = 2.5 , linestyle = ” - ” )
[<matplotlib.lines.Line2D object at 0xa27b42c>]
>>> pl.show( )

1.0

0.5

0.0

0.5

1.0 4 3 2 1 0 1 2 3 4

Figura 8 – Alterando espessura e cor da linha e dimensão da figura.

Com os parâmetros abaixo, pode-se limitar os limites dos eixos e alterar a identificação
dos pontos nos eixos:
>>> pl.xlim( X.min( ) * 1.1 , X.max( ) * 1.1 )
( -3.4557519189487729 , 3.4557519189487729 )
>>> pl.ylim( C.min( ) * 1.1 , C.max( ) * 1.1 )
( -1.1000000000000001 , 1.0999165211263138 )
>>> pl.plot( X , S , color = ’green’, linewidth = 2.5 , linestyle = ’-’ )
>>> pl.plot( X , C , color = ’red’, linewidth = 2.5 , linestyle = ’-’ )
>>> pl.xticks( [ -np.pi, -np.pi/2, 0, np.pi/2, np.pi ], [ r’−π’, r’−π/2’, r’0’, r’+π/2’,
r’+π’ ] )
>>> pl.yticks( [ -1, 0, +1 ],[ r’−1’, r’0’, r’+1’ ] )

Figura 9 – Alterando extremos das caixas e nomeando pontos sobre os eixos.

Com estas opções pode-se gerar eixos, retirar a caixa sobre o gráfico e criar legendas:

>>> ax = pl.gca()
>>> ax.spines[ ’right’ ].set color( ’none’ )
>>> ax.spines[ ’top’ ].set color( ’none’ )
>>> ax.xaxis.set ticks position( ’bottom’ )
>>> ax.spines[ ’bottom’ ].set position( ( ’data’ , 0 ) )
>>> ax.yaxis.set ticks position( ’left’ )
>>> ax.spines[ ’left’ ].set position( ( ’data’ , 0 ) )
>>> pl.plot( X , S , color = ’green’ , linewidth = 2.5 , linestyle = ’-’ , label = ’seno’ )
>>> pl.plot( X , C , color = ’red’ , linewidth = 2.5 , linestyle = ’-’ , label =
’cosseno’ )
>>> pl.legend( loc=’upper left’ )
Figura 10 – Alterando extremos das caixas e nomeando pontos sobre os eixos.

3.2 Gráficos 3D
Para gráficos 3D utiliza-se a função Axes3D do módulo mpl.toolkits.mplot3d, ob-
serve:

>>> import numpy as np


>>> import pylab as pl
>>> from mpl toolkits.mplot3d import Axes3D
>>> fig = pl.figure()
>>> ax = Axes3D( fig )
>>> X = np.arange( -4 , 4 , 0.25 )
>>> Y = np.arange( -4 , 4 , 0.25 )
>>> X , Y = np.meshgrid( X , Y )
>>> R = np.sqrt( X**2 + Y**2 )
>>> Z = np.sin( R )
>>> ax.plot surface( X , Y , Z , rstride=1 , cstride=1 , cmap=’hot’ )
>>> pl.show()
Figura 11 – Gráfico 3D.
4 Sympy

4.1 O que Computação Simbólica


A computação simbólica permite que sejam realizados cálculos com expressões matemáticas
simbólicas. A biblioteca que provê esta capacidade ao python chama-se Sympy. Veja o exem-
plo abaixo da resolução de uma equação quadrática com o uso do numpy e do sympy:

>>> # Numpy
>>>
>>> poly1d ([1 , -4 , -9])
2
1 x - 4 x - 9
>>> y = poly1d ([1 , -4 ,9])
>>> y . r
[ 5.60555128 -1.60555128]
>>>
>>> # sympy
>>>
>>> import sympy as sy
>>> sy . var ( ’x ’)
>>> Y = x **2 -4* x -9
>>> sy . solve (Y , x )
>>> [2 + sqrt (13) , - sqrt (13) + 2]

Observe outro exemplo interessante:

>>> import sympy as sy


>>> x , y = sy . symbols ( ’x , y ’)
>>> expr = x + 2* y
>>> expr
x + 2* y
>>> expr + 1
x + 2* y + 1
>>> expr - x
2* y
>>> x * expr
x *( x + 2* y )

O sympy nos oferece a possibilidade de trabalhar com integrais, derivadas, limites, resol-
ver equações, trabalhar com matrizes com elementos simbólicos, isto e muito mais.
4.2 Operações Básicas
Discutiremos aqui algumas das mais básicas operações a qual precisaremos para a mani-
pulação de expressões matemáticas com o sympy.
Vamos começar importando todas as funções da biblioteca, e também gerando os objetos
simbólicos.

>>> from sympy import *


>>> x , y , z = symbols ( "x , y , z " )

4.2.1 Substituições
Uma das coisas mais comuns que você pode querer fazer é a substituição. Como o próprio
nome diz, é a ação de substituir algo em uma expressão com outro valor ou outra expressão.
Faremos isso com o método subs.

4.2.1.1 Exemplos

a)

>>> expr = cos ( x ) + 1


>>> expr . subs (x , y )
cos ( y ) + 1
>>> expr . subs (x ,0)
2

b)

>>> expr = x ** y
>>> expr
x ** y
>>> expr = expr . subs (y , x ** y )
>>> expr
x **( x ** y )
>>> expr = expr . subs (y , x ** x )
>>> expr
x **( x **( x ** x ) )

c)
>>> expr = x **3 + 4* x * y - z
>>> expr . subs ([( x , 2) , (y , 4) , (z , 0) ])
40

4.2.1.2 Convertendo Strings em Expressões SymPy

A função sympify pode ser utilizado para converter strings em uma expressão sympy.
Veja:

>>> str_expr = " x **2 + 3* x - 1/2 "


>>> expr = sympify ( str_expr )
>>> expr
x **2 + 3* x - 1/2
>>> expr . subs (x , 2)
19/2

4.2.1.3 evalf

Para avaliar uma expressão numérica como ponto flutuante (float), use evalf.

>>> expr = sqrt (8)


>>> expr . evalf ()
2.82842712474619

SymPy pode calcular uma expressão numérica com precisão arbitrária. Por padrão 15
digitos de precisão são usados, mas você pode usar qualquer número de precisão como argu-
mento ao evalf. Como exemplo vamos calcular os 100 primeiros digitos do π.

>>> pi . evalf (100)


3.141592653589793238462643383279502884197169399375105820974944592
307816406286208998628034825342117068

Para calcular numéricamente uma expressão simbólica substituindo às variáveis numeros
de ponto flutuantes, basta usar o evalf seguido do subs. Observem:

>>> expr = cos (2* x )


>>> expr . evalf ( subs ={ x : 2.4})
0.087498 98 34 39 44 64
4.2.2 lambdify
subs e evalf são bons quando se quer um simples cálculo. Mas se você pretende calcular
uma função com muitos valores (utilizando um array) existem meios mais eficientes. Por
exemplo, se você deseja calcular uma função com uma sequência de milhares de elementos,
com SymPy provavelmente deverá ser muito lento, sendo uma ótima alternativa a utilização
das bibliotecas NumPy ou SciPy para resolvê-la.
O meio mais fácil de converter uma expressão SymPy em uma que pode ser numerica-
mente calculada é fazendo o uso da função lambdify. lambdify atua como um conversor a qual
troca-se a expressão SymPy para uma biblioteca numérica, usualmente NumPy ou SciPy.
A uilização da função lambdify é descrita no exemplo abaixo:

>>> import numpy


>>> a = numpy . arange (10)
>>> expr = sin ( x )
>>> f = lambdify (x , expr , " numpy " )
>>> f ( a )
[ 0. 0.84147098 0.90929743 0.14112001 -0.7568025
-0.95892427
-0.2794155 0.6569866 0.98935825 0.41211849]

4.3 Simplificações
Agora vamos começar a fazer uso de uma das habilidades mais interessantes da com-
putação simbólica, que é a simplificação de expressões matemáticas. O SymPy possui dezenas
de funções para executar vários tipos de simplificações. Aqui vamos conhecer as principais.
Para acesso a todas as funções de simplificações consulte http://docs.sympy.org/latest/tutorial
/simplification.html. Para continuar nesta seção vamos deixar algumas variáveis disponı́veis
para a utilização nos exemplos.

>>> from sympy import *


>>> x , y , z = symbols ( ’x y z ’)

4.3.1 simplify
simplify é uma função geral que possui a habilidade de utilizar todas as funções de
simplificação inteligentemente para obter expressões simplificadas. Observem:

>>> simplify ( sin ( x ) **2 + cos ( x ) **2)


1
>>> simplify (( x **3 + x **2 - x - 1) /( x **2 + 2* x + 1) )
x - 1

Mas tomem cuidado pois a função apenas tona as expressões simples e não a menor
possı́vel, para isso deve-se utilizar a função correta para cada caso. Por exemplo a função
x2 + 2x + 1 aplicada a simplify não retorna (x + 1)2 , mas factor sim. Vejam:

>>> y = x **2 + 2* x + 1
>>> simplify ( y )
x **2 + 2* x + 1
>>> factor ( y )
( x + 1) **2

4.3.2 Funções de Simplificação Polinomial


4.3.2.1 expand

expand é uma das mais comuns funções de simplificação do SymPy. Ele tem muitos
escopos, por agora nos atentaremos a expandir expressões polinomiais.

>>> expand (( x + 1) **2)


x **2 + 2* x + 1
>>> expand (( x + 2) *( x - 3) )
x **2 - x - 6

4.3.2.2 factor

A função factor fatora a expressão polinomial.

>>> factor ( x **3 - x **2 + x - 1)


( x - 1) *( x **2 + 1)
>>> factor ( x **2* z + 4* x * y * z + 4* y **2* z )
z *( x + 2* y ) **2

4.3.2.3 colect

Esta função provê deixar em evidência algum fator na expressão.

>>> expr = x * y + x - 3 + 2* x **2 - z * x **2 + x **3


>>> expr
x **3 - x **2* z + 2* x **2 + x * y + x - 3
>>> collected_expr = collect ( expr , x )
>>> collected_expr
x **3 + x **2*( - z + 2) + x *( y + 1) - 3

4.3.2.4 apart

A função apart decompõe a expressão em frações parciais.

>>> expr = (4* x **3 + 21* x **2 + 10* x + 12) /( x **4 + 5* x **3 + 5* x **2
+ 4* x )
>>> expr
(4* x **3 + 21* x **2 + 10* x + 12) /( x **4 + 5* x **3 + 5* x **2 + 4* x )
>>> apart ( expr )
(2* x - 1) /( x **2 + x + 1) - 1/( x + 4) + 3/ x

4.3.3 Simplificaçõs Trigonométricas


4.3.3.1 trigsimp

Para simplificar expressões usando entidades trigonométricas, use trigsimp

>>> trigsimp ( sin ( x ) **2 + cos ( x ) **2)


1
>>> trigsimp ( sin ( x ) **4 - 2* cos ( x ) **2* sin ( x ) **2 + cos ( x ) **4)
cos (4* x ) /2 + 1/2
>>> trigsimp ( sin ( x ) * tan ( x ) / sec ( x ) )
sin ( x ) **2
>>> trigsimp ( cosh ( x ) **2 + sinh ( x ) **2)
cosh (2* x )
>>> trigsimp ( sinh ( x ) / tanh ( x ) )
cosh ( x )

4.3.3.2 expand trig

Para expandir funções trigonométricas com entidades de soma ou ângulos múltiplos.

>>> expand_trig ( cos (3* x ) )


4* cos ( x ) **3 - 3* cos ( x )
>>> expand_trig ( sin ( x + y ) )
sin ( x ) * cos ( y ) + sin ( y ) * cos ( x )
>>> expand_trig ( tan (2* x ) )
2* tan ( x ) /( - tan ( x ) **2 + 1)
4.4 Cálculo Diferencial e Integral
4.4.1 Derivadas
Para resolver derivadas use a função diff.

>>> diff ( cos ( x ) ,x )


- sin ( x )
>>> diff ( exp ( x **2) , x )
2* x * exp ( x **2)

diff pode efetuar derivadas múltiplas. Para efetuar derivadas múltiplas basta adicionar
n-vezes a variável como argumento, ou adicionar após o argumento da variável a quantidade
de vezes a qual deverá derivar.

>>> diff ( x **4 , x , x , x )


24* x
>>> diff ( x **4 , x , 3)
24* x

Esta função também efetua derivadas de várias variáveis, bastando adicionar as variáveis
como argumento da função, lembrando que a ordem de derivação será seguida da esquerda
para a direita.

>>> expr = exp ( x * y * z )


>>> diff ( expr , x , y , y , z , z , z , z )
x **3* y **2*( x **3* y **3* z **3 + 14* x **2* y **2* z **2 + 52* x * y * z + 48) *
exp ( x * y * z )
>>> diff ( expr , x , y , 2 , z , 4)
x **3* y **2*( x **3* y **3* z **3 + 14* x **2* y **2* z **2 + 52* x * y * z + 48) *
exp ( x * y * z )
>>> diff ( expr , x , y , y , z , 4)
x **3* y **2*( x **3* y **3* z **3 + 14* x **2* y **2* z **2 + 52* x * y * z + 48) *
exp ( x * y * z )

diff também pode ser chamado como método.

>>> expr . diff (x , y , y , z , 4)


x **3* y **2*( x **3* y **3* z **3 + 14* x **2* y **2* z **2 + 52* x * y * z + 48) *
exp ( x * y * z )
4.4.2 Integrais
Para calcular integrais usamos a função integrate. Podemos com a função, calcular uma
integral indefinida colocando como argumento apenas as variáveis, e também pode-se calcular
uma integral definida colocando como argumento uma sequência com a variável, o limite
inferior e o limite superior. Observe:

>>> Y = x **4* cos (2* x )


>>> integrate (Y , x )
x **4* sin (2* x ) /2 + x **3* cos (2* x ) - 3* x **2* sin (2* x ) /2 - 3* x * cos (2* x
) /2 + 3* sin (2* x ) /4
>>> integrate (Y ,( x ,0 ,10) )
985* cos (20) + 19403* sin (20) /4

Também pode-se calcular integrais multiplas apenas adicionando as informações das ou-
tras variáveis como argumento. Vejam:

>>> Z = x **3 - y **2* cos ( x )


>>> integrate (Z ,x , y )
x **4* y /4 - y **3* sin ( x ) /3
>>> integrate (Z ,( x ,0 ,3) ,(y , -10 ,1) )
-1001* sin (3) /3 + 891/4

4.5 Limites
SymPy pode calcular o limite de expressões simbólicas como

lim f (x)
x→x0

Com a seguinte sintaxe: limit(f(x),x,x0).

>>> limit ( sin ( x ) /x , x , 0)


1

Para calcular o limites laterais basta adicionar ”+”ou ”−”como um terceiro argumento
ao limite.

>>> limit (1/ x , x , 0 , ’+ ’)


oo
>>> limit (1/ x , x , 0 , ’ - ’)
- oo
5 Exercı́cios de Fixação

1. Faça uma função para a conversão de milı́metro para polegada e vice-versa. Faça a
função imprimir na tela mensagem semelhante a ” 1 polegada = 25,4 mm”, e faça as
conversões correspondentes.

a) Converta para polegada as medidas em milı́metros: 55,3 ; 689,2 ; 23,1 ; 98,35 ; 12,7
; 4985,22 ; 0,5432 ; 15549,13 ; 0,1
b) Converta para milı́metro as medidas em polegadas: 0,593 ; 2,5 ; 6,831 ; 38,476 ;
962,197 ; 49,434 ; 111,639 ; 726,3 ; 0,005

2. Encontre os valores das correntes elétricas principais do circuito abaixo:

Figura 12 – Circuito para o exercı́cio 2.

3. Uma análise muito importante para tratamento de água industrial é sı́lica solúvel
alto teor, que é uma análise espectrofotométrica. Para se realizar análises de sı́lica
solúvel alto teor, o analista deve primeiramente realizar a curva de calibração para o
espectrofotômetro e reagentes que irá utilizar. Um analista realizando uma curva de
calibração obteve os seguintes dados:

Concentração (mg/L) Absorbância


5 0,263
10 0,458
15 0,62
20 0,781

Tabela 9 – Dados para curva de calibração de sı́lica solúvel.

Determine:

a) A equação de calibração do equipamento, e o coeficiente de determinação (r2 ).


b) Encontre a concentração das análises realizadas.
Ponto de Coleta Absorbância Concentração (mg/L)
Alimentação caldeira 0,118
Caldeira 0,691
torre de resfriamento 01 0,422
torre de resfriamento 02 0,318
poço 0,253

4. A posição de uma partı́cula que se desloca ao longo de uma linha reta é definida pela
relação x = 0, 3 t3 − 1, 8/t2 − 4, 5 t + 12, onde x é expresso em metros e t em segundos.
Determine:

a) O instante em que a velocidade será zero.


b) A posição e a distância percorrida pela partı́cula nesse instante.
c) A aceleração da partı́cula nesse instante.
d) Faça um gráfico da posição, velocidade e aceleração em função do tempo.
e) A distância. percorrida pela partı́cula de t = 4 s a t = 6 s

5. Resolva a equação transcendental −2 x − 3 cos(x2 ) = 0 executando os passos:

a) Faça um gráfico da função informando uma faixa aproximada de x ao qual o zero


da função se encontra.
b) Faça uma função com os argumentos: x (faixa de x encontrado acima), p (precisão),
para encontrar o zero da função com um erro menor que 0,00001.
Referências

[1] PYTHON SCIENTIFIC LECTURE NOTES. In: EUROSCIPY 2012., 2012/3. Dis-
ponı́vel em: <http://scipy-lectures.github.com>. Acesso em: 21 nov de 2014.

[2] FANGOHR, H. Python for Computational Science and Engineering. 1. ed. Nova York:
Cambridge, 2006.

[3] LANGTANGEN, H. P. A Primer on Scientific Programming with Python. 2. ed. Ber-


lim: Springer, 2011.

[4] MADRONA, F. E. Pressões em Silos Esbeltos com Descarga Excêntrica. 2008. Dis-
sertação (Mestrado em Engenharia de Estruturas) - Escola de Engenharia de São
Carlos, Universidade de São Paulo, São Carlos, 2008.

[5] KIUSALAAS, J. Numerical Methods in Engineering with Python. 1. ed. Nova York:
Cambridge, 2005.

[6] https://www.python.org/doc/essays/blurb/