PYTHON APLICADO A CIÊNCIA E ENGENHARIA

VICTOR HUGO GARCIA DE CAMPOS

ROSEVALDO DE OLIVEIRA

Rondonópolis - outubro de 2013

Sumário

1 Primeiros Contatos com o Python 3

1.1 Módulos padrão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Sequências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.1 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.2 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.3 Tupla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3 Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.1 Definindo Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Controle de Fluxo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4.1 Condicionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4.2 If - Then - Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.3 Laço For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4.4 Laço While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2 Numpy 14
2.1 Funções Matemáticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.1 Funções Gerais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.2 Números Complexos . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.1 Criando Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 Álgebra Linear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3.1 Utilizando arrays como matrizes . . . . . . . . . . . . . . . . . . . . . 18
2.3.2 Produto Escalar e Vetorial . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4 Polinômios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.5 Estatı́stica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3 Matplotlib 23
3.1 Pylab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.1.1 Configurações Padrões . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.1.2 Alterando Cores e Largura das Linhas . . . . . . . . . . . . . . . . . 24
3.1.3 Configurando os Limites dos Eixos da imagem . . . . . . . . . . . . . 25
3.1.4 Configurando Referências dos Eixos . . . . . . . . . . . . . . . . . . . 26
3.1.5 Movendo os Eixos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1.6 Adicionando a Legenda . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.1.7 Outros Tipos de Gráficos . . . . . . . . . . . . . . . . . . . . . . . . . 28

4 Sympy 34
4.1 O que Computação Simbólica . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.2 Operações Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.2.1 Substituições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.2.2 lambdify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

1
SUMÁRIO 2

4.3 Simplificações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3.1 simplify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3.2 Funções de Simplificação Polinomial . . . . . . . . . . . . . . . . . . . 37
4.3.3 Simplificaçõs Trigonométricas . . . . . . . . . . . . . . . . . . . . . . 38
4.4 Cálculo Diferencial e Integral . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.4.1 Derivadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.4.2 Integrais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.5 Limites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Capı́tulo 1

Primeiros Contatos com o Python

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 pagos, devido ao
empenho de diversos cientistas do mundo inteiro.
No terminal linux o comando ’python’, iniciará o programa, verão o seguinte:

Figura 1.1: Comando python no emulador de terminal linux

Ao iniciar o python, o terminal nos mostra a versão, que no caso é a 2.7.5, versão que
trabalharemos aqui. Hoje a versão mais atual é a 3.x, porém a 2.7.x é a versão que mais
módulos cientı́ficos possui.
O prompt do python é o simbolo >>>, quando este aparece, significa que o python está
esperando o comando do usuário.

1.1 Módulos padrão

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:

3
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 4

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

O sinal ” = ” é utilizado para atribuir valores a uma variável. E ” ” é usado para utilizar
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 a 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
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 5

>>> 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 [Link]. 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 ’ >
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 6

1.2 Sequências
Strings, listas e tuplas, são sequências. Eles 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 sequncia a
a + b concatena a e b
n ∗ a cria n cópias da sequência a

Tabela 1.1: Alguns comandos úteis para sequências.

1.2.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.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:
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 7

>>> 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.2.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.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
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 8

>>> 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]
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 9

1.2.3 Tupla
Tuplas são sequências muito parecidas com listas, porém são imutáveis.
Atribuı́mos uma tupla a uma variável, colocando os objetos separados por vı́rgula, po-
dendo estar contidos entre parêntesis.
Assim como as listas, podem ser incluı́dos na tupla objetos de quaisquer tipos de variáveis.
Gera-se uma tupla vazia apenas com parêntesis.
Exemplos:

>>> a = (2 , " a " , [1 ,2 ,9])

>>> a
(2 , ’a ’ , [1 , 2 , 9])
>>> len ( a )
3
>>> max ( a )
’a ’
>>> a [1]
’a ’
>>> a [2]*2
[1 , 2 , 9 , 1 , 2 , 9]
>>> a [0] = 10
Traceback ( most recent call last ) :
File " < stdin > " , line 1 , in < module >
TypeError : ’ tuple ’ object does not support item assignment
>>> b = 2 , " ba " , (1 ,2 ,3)
>>> b
(2 , ’ ba ’ , (1 , 2 , 3) )

1.3 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.3.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:
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 10

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.4 Controle de Fluxo

1.4.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
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 11

>>> 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.4.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 :
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 12

... 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.4.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.4.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
CAPÍTULO 1. PRIMEIROS CONTATOS COM O PYTHON 13

>>> 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 numero inteiro positivo : ’)

Digite um numero inteiro positivo : 15
>>> c = n
>>> res = 1
>>> while c > 1:
... res = res * c
... c = c - 1
...
>>> print n , ’! = ’ ,res , ’ . ’
15 ! = 1307674368000 .
Capı́tulo 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.1: 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

14
CAPÍTULO 2. NUMPY 15

>>> hypot (3 ,4)

5.0

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 2.2: 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 )
CAPÍTULO 2. NUMPY 16

4.0
>>> conj ( a )
(3 -6 j )

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
CAPÍTULO 2. NUMPY 17

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 2.3: 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 :
CAPÍTULO 2. NUMPY 18

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

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:
[Link](a) Calcula o determinante de um array
dot( x, y ) retorna o produto matricial entre x e y
[Link]( a ) retorna a matriz inversa de a
transpose( a ) retorna a matriz transposta de a

Tabela 2.4: 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] ,
CAPÍTULO 2. NUMPY 19

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

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 2.5: Funções de álgebra vetorial.

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])
CAPÍTULO 2. NUMPY 20

>>> cross (v , u )
array ([ -55 , 72 , 23])

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 2.6: Funções polinomiais.

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 ,
CAPÍTULO 2. NUMPY 21

-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 2.7: 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.

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 ,
CAPÍTULO 2. NUMPY 22

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

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.
Capı́tulo 3

Matplotlib

3.1 Pylab
O Pylab é um módulo do Matplotilib que permite a construção de gráficos de ótima
qualidade com possibilidade de edição, sendo possı́vel adicionar legendas, textos, figuras,
anotações, etc...

3.1.1 Configurações Padrões

Aqui vamos construir um gráfico com
seno e cosseno utilizando as configurações 1.0
padrões do pylab. Observe:

0.5

from pylab import * 0.0

X = linspace ( - pi , pi ,256)
C , S = cos ( X ) , sin ( X )
plot (X , C ) 0.5
plot (X , S )
show ()
1.0
4 3 2 1 0 1 2 3 4

Figura 3.1: Primeiros passos.

Neste passo vamos deixar explicito todas as configurações padrões que estão implı́citas
no exemplo acima.
from pylab import *
figure ( figsize =(8 ,6) , dpi =80)
subplot (1 ,1 ,1)
X = linspace ( - pi , pi ,256)
C , S = cos ( X ) , sin ( X )
plot (X , C , color = " blue " , linewidth =1.0 , linestyle = " -" )
plot (X , S , color = " green " , linewidth =1.0 , linestyle = " -" )
xlim ( -4.0 ,4.0)
xticks ( np . linspace ( -4 ,4 ,9 , endpoint = True ) )

23
CAPÍTULO 3. MATPLOTLIB 24

ylim ( -1.0 ,1.0)

yticks ( np . linspace ( -1 ,1 ,5 , endpoint = True ) )
show ()

1.0

0.5

0.0

0.5

1.0
4 3 2 1 0 1 2 3 4

Figura 3.2: Configurações discriminadas.

3.1.2 Alterando Cores e Largura das Linhas

Primeiramente vamos modificar as cores de cada um, passando o cosseno para azul e o
seno para vermelho, aumentar a espessura da linha de ambos e deixar a figura horizontal-
mente maior.
from pylab import *
figure ( figsize =(10 ,6) , dpi =80)
X = linspace ( - pi , pi ,256)
C , S = cos ( X ) , sin ( X )
plot (X , C , color = " blue " , linewidth =3.0 , linestyle = " -" )
plot (X , S , color = " red " , linewidth =3.0 , linestyle = " -" )
show ()
CAPÍTULO 3. MATPLOTLIB 25

1.0

0.5

0.0

0.5

1.0
4 3 2 1 0 1 2 3 4

Figura 3.3: Alterando cores e linhas.

3.1.3 Configurando os Limites dos Eixos da imagem

Neste passo vamos configurar os limites dos eixos da imagem de forma que fiquem 10%
maior em ambas as extremidades.
from pylab import *
figure ( figsize =(10 ,6) , dpi =80)
X = linspace ( - pi , pi ,256)
C , S = cos ( X ) , sin ( X )
plot (X , C , color = " blue " , linewidth =3.0 , linestyle = " -" )
plot (X , S , color = " red " , linewidth =3.0 , linestyle = " -" )
xlim ( X . min () *1.1 , X . max () *1.1)
ylim ( C . min () *1.1 , C . max () *1.1)
show ()

1.0

0.5

0.0

0.5

1.0
3 2 1 0 1 2 3

Figura 3.4: Alterando cores e linhas.

CAPÍTULO 3. MATPLOTLIB 26

3.1.4 Configurando Referências dos Eixos

Vamos agora configurar os valores que aparecem como referência nos eixos de coordena-
das.
from pylab import *
figure ( figsize =(10 ,6) , dpi =80)
X = linspace ( - pi , pi ,256)
C , S = cos ( X ) , sin ( X )
plot (X , C , color = " blue " , linewidth =3.0 , linestyle = " -" )
plot (X , S , color = " red " , linewidth =3.0 , linestyle = " -" )
xlim ( X . min () *1.1 , X . max () *1.1)
xticks ([ - pi , - pi /2 ,0 , pi /2 , pi ] ,[ r ’$ -\ pi$ ’ , r ’$ -\ pi /2 $ ’ , r ’ $0$ ’ , r ’$ \
pi /2 $ ’ , r ’$ \ pi$ ’ ])
ylim ( C . min () *1.1 , C . max () *1.1)
yticks ([ -1 , -0.5 , 0 , 0.5 , 1] ,[ r ’ -1 ’ , r ’ -1/2 ’ , r ’0 ’ , r ’ 1/2 ’ , r ’1 ’ ])
show ()

1/2

-1/2

-1
−π −π/2 0 π/2 π

Figura 3.5: Alterando referências dos eixos.

3.1.5 Movendo os Eixos

Nesta etapa vamos mover os eixos até sua intersecção com a origem.
from pylab import *
figure ( figsize =(10 ,6) , dpi =80)
X = linspace ( - pi , pi ,256)
C , S = cos ( X ) , sin ( X )
ax = gca ()
ax . spines [ ’ right ’ ]. set_color ( ’ none ’)
ax . spines [ ’ top ’ ]. set_color ( ’ none ’)
ax . xaxis . set _t ic ks _p os it io n ( ’ bottom ’)
ax . spines [ ’ bottom ’ ]. set_position (( ’ data ’ ,0) )
ax . yaxis . set _t ic ks _p os it io n ( ’ left ’)
ax . spines [ ’ left ’ ]. set_position (( ’ data ’ ,0) )
plot (X , C , color = " blue " , linewidth =3.0 , linestyle = " -" )
plot (X , S , color = " red " , linewidth =3.0 , linestyle = " -" )
CAPÍTULO 3. MATPLOTLIB 27

xlim ( X . min () *1.1 , X . max () *1.1)

xticks ([ - pi , - pi /2 ,0 , pi /2 , pi ] ,[ r ’$ -\ pi$ ’ , r ’$ -\ pi /2 $ ’ , r ’ $0$ ’ , r ’$ \
pi /2 $ ’ , r ’$ \ pi$ ’ ])
ylim ( C . min () *1.1 , C . max () *1.1)
yticks ([ -1 , -0.5 , 0 , 0.5 , 1] ,[ r ’ -1 ’ , r ’ -1/2 ’ , r ’0 ’ , r ’ 1/2 ’ , r ’1 ’ ])
show ()

1/2

−π −π/2
0 π/2 π
0

-1/2

-1

Figura 3.6: Movendo os eixos de coordenadas.

3.1.6 Adicionando a Legenda

Agora iremos adicionar a legenda.
from pylab import *
figure ( figsize =(10 ,6) , dpi =80)
X = linspace ( - pi , pi ,256)
C , S = cos ( X ) , sin ( X )
ax = gca ()
ax . spines [ ’ right ’ ]. set_color ( ’ none ’)
ax . spines [ ’ top ’ ]. set_color ( ’ none ’)
ax . xaxis . set _t ic ks _p os it io n ( ’ bottom ’)
ax . spines [ ’ bottom ’ ]. set_position (( ’ data ’ ,0) )
ax . yaxis . set _t ic ks _p os it io n ( ’ left ’)
ax . spines [ ’ left ’ ]. set_position (( ’ data ’ ,0) )
plot (X , C , color = " blue " , linewidth =3.0 , linestyle = " -" , label = "
cosseno " )
plot (X , S , color = " red " , linewidth =3.0 , linestyle = " -" , label = " seno "
)
xlim ( X . min () *1.1 , X . max () *1.1)
xticks ([ - pi , - pi /2 ,0 , pi /2 , pi ] ,[ r ’$ -\ pi$ ’ , r ’$ -\ pi /2 $ ’ , r ’ $0$ ’ , r ’$ \
pi /2 $ ’ , r ’$ \ pi$ ’ ])
ylim ( C . min () *1.1 , C . max () *1.1)
yticks ([ -1 , -0.5 , 0 , 0.5 , 1] ,[ r ’ -1 ’ , r ’ -1/2 ’ , r ’0 ’ , r ’ 1/2 ’ , r ’1 ’ ])
legend ( loc = ’ upper left ’)
show ()
CAPÍTULO 3. MATPLOTLIB 28

cosseno 1
seno

1/2

−π −π/2
0 π/2 π
0

-1/2

-1

Figura 3.7: Adicionando legenda.

Exercı́cios
1. Faça um gráfico simples com o Pylab das funções abaixo:

a) e−x sin(x) x2
b) ln(sin(x))
c) cos(x2 ) xx

2. Faça uma função com argumentos de dados x e dedos y (def p(dadosx, dadosy) para
uma configuração personalizada de um gráfico a qual achou interessante.

3.1.7 Outros Tipos de Gráficos

Abaixo segue algumas outras possibilidades de gráficos com o pylab.

Gráficos com áreas preenchidas

from pylab import * fill_between (X , -1 , Y -1 , (Y -1)

n = 256 < -1 , color = ’ red ’ , alpha
X = np . linspace ( - np . pi , np . pi ,n , =.25)
endpoint = True ) xlim ( - np . pi , np . pi ) , xticks ([])
Y = np . sin (2* X ) ylim ( -2.5 ,2.5) , yticks ([])
axes ([0.025 ,0.025 ,0.95 ,0.95]) show ()
plot (X , Y +1 , color = ’ blue ’ ,
alpha =1.00)
fill_between (X , 1 , Y +1 , color = ’
blue ’ , alpha =.25)
plot (X , Y -1 , color = ’ blue ’ ,
alpha =1.00)
fill_between (X , -1 , Y -1 , (Y -1)
> -1 , color = ’ blue ’ , alpha
=.25)
CAPÍTULO 3. MATPLOTLIB 29

Figura 3.8: Áreas preenchidas.

Gráficos de dispersão

from pylab import *

n = 1024
X = np . random . normal (0 ,1 , n )
Y = np . random . normal (0 ,1 , n )
T = np . arctan2 (Y , X )
axes ([0.025 ,0.025 ,0.95 ,0.95])
scatter (X ,Y , s =75 , c =T , alpha
=.5)
xlim ( -1.5 ,1.5) , xticks ([])
ylim ( -1.5 ,1.5) , yticks ([])
show ()

Figura 3.9: Dispersão.

Gráficos de barras

from pylab import * text ( x +0.4 , -y -0.05 , ’ %.2 f ’

n = 12 % y , ha = ’ center ’ , va = ’
X = np . arange ( n ) top ’)
Y1 = (1 - X / float ( n ) ) * np . random xlim ( -.5 , n ) , xticks ([])
. uniform (0.5 ,1.0 , n ) ylim ( -1.25 ,+1.25) , yticks ([])
Y2 = (1 - X / float ( n ) ) * np . random show ()
. uniform (0.5 ,1.0 , n )
axes ([0.025 ,0.025 ,0.95 ,0.95])
bar (X , + Y1 , facecolor = ’ #9999 ff ’
, edgecolor = ’ white ’)
bar (X , -Y2 , facecolor = ’# ff9999 ’
, edgecolor = ’ white ’)
for x , y in zip (X , Y1 ) :
text ( x +0.4 , y +0.05 , ’ %.2 f ’
% y , ha = ’ center ’ , va = ’
bottom ’)
for x , y in zip (X , Y2 ) :
CAPÍTULO 3. MATPLOTLIB 30

Figura 3.10: Gráfico comum.

Gráficos de contorno

from pylab import *

def f (x , y ) : return (1 - x /2+ x **5+
y **3) * np . exp ( - x **2 - y **2)
n = 256
x = np . linspace ( -3 ,3 , n )
y = np . linspace ( -3 ,3 , n )
X , Y = np . meshgrid (x , y )
axes ([0.025 ,0.025 ,0.95 ,0.95])
contourf (X , Y , f (X , Y ) , 8 , alpha
=.75 , cmap = cm . hot )
C = contour (X , Y , f (X , Y ) , 8 ,
colors = ’ black ’ , linewidth
=.5)
clabel (C , inline =1 , fontsize
=10) Figura 3.11: Gráfico de contorno.
xticks ([]) , yticks ([])
show ()

Gráficos de mapas de cores

from pylab import * axes ([0.025 ,0.025 ,0.95 ,0.95])

def f (x , y ) : return (1 - x /2+ x **5+ imshow (Z , interpolation = ’ nearest
y **3) * np . exp ( - x **2 - y **2) ’ , cmap = ’ bone ’ , origin = ’
n = 10 lower ’)
x = np . linspace ( -3 ,3 ,3.5* n ) colorbar ( shrink =.92)
y = np . linspace ( -3 ,3 ,3.0* n ) xticks ([]) , yticks ([])
X , Y = np . meshgrid (x , y ) show ()
Z = f (X , Y )
CAPÍTULO 3. MATPLOTLIB 31

Figura 3.12: Mapa de cores.

Gráficos tipo pizza

from pylab import *

n = 20
Z = np . ones ( n )
Z [ -1] *= 2
axes ([0.025 ,0.025 ,0.95 ,0.95])
pie (Z , explode = Z *.05 , colors =
[ ’% f ’ % ( i / float ( n ) ) for i
in range ( n ) ])
gca () . set_aspect ( ’ equal ’)
xticks ([]) , plt . yticks ([])
show ()

Figura 3.13: Gráfico tipo pizza.

Gráficos vetoriais

from pylab import *

n = 8
X , Y = np . mgrid [0: n ,0: n ]
T = np . arctan2 (Y - n /2.0 , X - n
/2.0)
R = 10+ np . sqrt (( Y - n /2.0) **2+( X -
n /2.0) **2)
U , V = R * np . cos ( T ) , R * np . sin ( T )
axes ([0.025 ,0.025 ,0.95 ,0.95])
quiver (X ,Y ,U ,V ,R , alpha =.5)
quiver (X ,Y ,U ,V , edgecolor = ’k ’ ,
facecolor = ’ None ’ , linewidth
=.5)
xlim ( -1 , n ) , xticks ([])
ylim ( -1 , n ) , yticks ([]) Figura 3.14: Gráficos vetoriais.
show ()
CAPÍTULO 3. MATPLOTLIB 32

Gráficos polares

from pylab import * show ()

ax = axes
([0.025 ,0.025 ,0.95 ,0.95] ,
polar = True )
N = 20
theta = np . arange (0.0 , 2* np . pi ,
2* np . pi / N )
radii = 10* np . random . rand ( N )
width = np . pi /4* np . random . rand (
N)
bars = bar ( theta , radii , width =
width , bottom =0.0)
for r , bar in zip ( radii , bars ) :
bar . set_facecolor ( cm . jet ( r
/10.) )
bar . set_alpha (0.5)
ax . set_xticklabels ([])
ax . set_yticklabels ([]) Figura 3.15: Gráficos polares.

Gráficos 3D

from pylab import *

from mpl_toolkits . mplot3d
import Axes3D
fig = 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 =
cm . hot )
ax . contourf (X , Y , Z , zdir = ’z ’ ,
offset = -2 , cmap = cm . hot ) Figura 3.16: Gráficos 3D.
ax . set_zlim ( -2 ,2)
show ()

Gráficos com textos

from pylab import * alpha ^\ prime_2U ^{1\ beta } _ {\

rho_1 \ sigma_2 } }{ U ^{0\ beta }
eqs = [] _ {\ rho_1 \ sigma_2 }}\ right ] $ "
eqs . append (( r " $W ^{3\ beta } _ {\ ))
delta_1 \ rho_1 \ sigma_2 } = U eqs . append (( r " $ \ frac { d \ rho }{ d t
^{3\ beta } _ {\ delta_1 \ rho_1 } } + \ rho \ vec { v }\ cdot \ nabla \
+ \ frac {1}{8 \ pi 2} \ int ^{\ vec { v } = -\ nabla p + \ mu \
alpha_2 } _ {\ alpha_2 } d \ alpha nabla ^2 \ vec { v } + \ rho \ vec {
^\ prime_2 \ left [\ frac { U ^{2\ g}$"))
beta } _ {\ delta_1 \ rho_1 } - \
CAPÍTULO 3. MATPLOTLIB 33

eqs . append (( r " $ \ int_ { -\ infty }^\ transform = gca () .

infty e ^{ - x ^2} dx =\ sqrt {\ pi } $ transAxes , fontsize
")) = size , clip_on = True
eqs . append (( r " $E = mc ^2 = \ sqrt )
{{ m_0 }^2 c ^4 + p ^2 c ^2} $ " ) ) xticks ([]) , yticks ([])
eqs . append (( r " $F_G = G \ frac { show ()
m_1m_2 }{ r ^2} $ " ) )
axes ([0.025 ,0.025 ,0.95 ,0.95])
for i in range (24) :
index = np . random . randint
(0 , len ( eqs ) )
eq = eqs [ index ]
size = np . random . uniform
(12 ,32)
x , y = np . random . uniform
(0 ,1 ,2)
alpha = np . random . uniform
(0.25 ,.75)
text (x , y , eq , ha = ’ center ’ ,
va = ’ center ’ , color = "
#11557 c " , alpha = alpha ,
Figura 3.17: Gráfico com textos.
Capı́tulo 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.

34
CAPÍTULO 4. SYMPY 35

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.

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

Convertendo Strings em Expressões SymPy

A função sympify pode ser utilizado para converter strings em uma expressão sympy.
Veja:
CAPÍTULO 4. SYMPY 36

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

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
CAPÍTULO 4. SYMPY 37

-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 [Link]
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

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
CAPÍTULO 4. SYMPY 38

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

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

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

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 )
CAPÍTULO 4. SYMPY 39

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.

CAPÍTULO 4. SYMPY 40

>>> 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
Referências Bibliográficas

vwnifqwoief
1 PYTHON SCIENTIFIC LECTURE NOTES. In: EUROSCIPY 2012., 2012/3. Disponı́vel
em: <[Link] Acesso em: 21 dez de 2012.

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. Berlim:

Springer, 2011.

4 KIUSALAAS, J. Numerical Methods in Engineering with Python. 1. ed. Nova York:

Cambridge, 2005.

5 MUNSON B. R.; YOUNG, D. F. Fundamentos da Mecânica dos Fluidos. 1. ed. São

Paulo-SP: Editora Edgard blücher Ltda, 2004.

41