python_book

Prévia do material em texto

See discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/307925106
Computação Científica usando Python: uma introdução a linguagem de
programação.
Book · September 2016
CITATIONS
0
READS
5,093
2 authors:
Some of the authors of this publication are also working on these related projects:
Computação Científica View project
Física Teórica View project
Rosevaldo de Oliveira
Universidade Federal de Mato Grosso (UFMT)
4 PUBLICATIONS   11 CITATIONS   
SEE PROFILE
Victor Hugo Garcia Campos
University of Campinas
2 PUBLICATIONS   0 CITATIONS   
SEE PROFILE
All content following this page was uploaded by Rosevaldo de Oliveira on 08 September 2016.
The user has requested enhancement of the downloaded file.
https://www.researchgate.net/publication/307925106_Computacao_Cientifica_usando_Python_uma_introducao_a_linguagem_de_programacao?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_2&_esc=publicationCoverPdf
https://www.researchgate.net/publication/307925106_Computacao_Cientifica_usando_Python_uma_introducao_a_linguagem_de_programacao?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_3&_esc=publicationCoverPdf
https://www.researchgate.net/project/Computacao-Cientifica?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_9&_esc=publicationCoverPdf
https://www.researchgate.net/project/Fisica-Teorica?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_9&_esc=publicationCoverPdf
https://www.researchgate.net/?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_1&_esc=publicationCoverPdf
https://www.researchgate.net/profile/Rosevaldo_Oliveira?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_4&_esc=publicationCoverPdf
https://www.researchgate.net/profile/Rosevaldo_Oliveira?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_5&_esc=publicationCoverPdf
https://www.researchgate.net/institution/Universidade_Federal_de_Mato_Grosso_UFMT?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_6&_esc=publicationCoverPdf
https://www.researchgate.net/profile/Rosevaldo_Oliveira?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_7&_esc=publicationCoverPdf
https://www.researchgate.net/profile/Victor_Campos16?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_4&_esc=publicationCoverPdf
https://www.researchgate.net/profile/Victor_Campos16?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_5&_esc=publicationCoverPdf
https://www.researchgate.net/institution/University_of_Campinas?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_6&_esc=publicationCoverPdf
https://www.researchgate.net/profile/Victor_Campos16?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_7&_esc=publicationCoverPdf
https://www.researchgate.net/profile/Rosevaldo_Oliveira?enrichId=rgreq-6ecfd73b3fceb89352ec57ad2bc283e9-XXX&enrichSource=Y292ZXJQYWdlOzMwNzkyNTEwNjtBUzo0MDQxNTk4ODM5NTYyMjhAMTQ3MzM3MDYzMzU4Mg%3D%3D&el=1_x_10&_esc=publicationCoverPdf
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 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.1.2 Números Complexos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.1.2.1 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.2 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.2.1 Criando Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.2.1.1 Exerćıcios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3 Álgebra Linear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3.1 Utilizando arrays como matrizes . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3.1.1 Exerćıcios: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.3.2 Produto Escalar e Vetorial . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.3.2.1 Exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.3.2.2 Exerćı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 Exerćı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 EXERĆICIOS DE FIXAÇÃO . . . . . . . . . . . . . . . . . . . . . . . 48
REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1 Primeiros Contatos
Python é uma linguagem de programação interpretada, orientada à objeto, de alto ńı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 prinćı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 súıç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 dispońıveis, porém hoje
não acontece mais.
É óbvio que é posśıvel encontrar uma ou outra biblioteca dispońıvel para uma das duas
versões, porém estudando uma dela é posśı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.141592653589793
In [3]: math.cos(math.radians (30))
Out [3]: 0.8660254037844387
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.70710678118654746
In [7]: sin(radians (90))
Out [7]: 1.0
In [8]: cos(radians (90))
Out [8]: 6.123233995736766e-17
In [9]: exp(-radians (36))*cos(radians (36))
Out [9]: 0.43160093198935257
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 0x7f7e940e6050 >]
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+7j)+(3-8j)
(4-1j)
>>> 2**2
4
>>> 2-5
-3
>>> 3**(0.5)
1.7320508075688772
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.5555702330196022
>>> 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 dispońı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 prinćı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
2147483648L
>>> 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. Atribúı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çandocom 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 y2 − 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 retornar_asterisco(n):
... return n* "*"
...
>>> def imp_string_ast(string):
... comp_linha = 46
... ast_str = retornar_asterisco (( 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 gostaŕı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.86602540378443871
>>> cos(x)
-0.49999999999999978
>>> sin(x)**2 + cos(x)**2
0.99999999999999989
>>> log (4)
1.3862943611198906
>>> log(exp (1))
1.0
>>> log10 (10)
1.0
>>> log2 (2)
1.0
>>> hypot (3,4)
5.0
2.1.1.1 Exerćıcios
1. Calcule as seguintes funções para os valores (−11, 43, 8976, 0.00036).
a) sin(x) ex/2
b) ln(x) sin2(x) + cos(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√
f
= −2 log
(
�/D
3, 7
+
2, 51
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 -2j
>>> a+b
(-2+4j)
>>> a/b
( -0.9310344827586208 -0.8275862068965517j)
>>> a*b
(-3-36j)
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+6j), (-5-2j)]
>>> 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-6j)
2.1.2.1 Exerćıcios
1. Resolva as seguintes operações:
a) (2 - 5i) + (-3 + 3i)
b)
(5− 2i)
(5− 6i)
− (2− 4i).(5− 2i)
c)
(3− 6i)2 + (5 + 4i)3
(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.94885134e-310, 1.52578222e-316, 6.94884893e-310,
6.94885170e-310] ,
[ 6.94885174e-310, 6.94884729e-310, 6.94885171e-310,
1.66047005e-316] ,
[ 6.94884729e-310, 6.94885173e-310, 6.94885170e-310,
6.94885170e-310] ,
[ 6.94885170e-310, 6.94885173e-310, 6.94884858e-310,
6.94885171e -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 Exerćı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 Exerćı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 Exerćı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 ráızes
roots( p ) Retorna as ráı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.03717038+2.05600758j, 2.03717038 -2.05600758j,
-1.07434076+0.j ])
>>> y.r
array([ 2.03717038+2.05600758j, 2.03717038 -2.05600758j,
-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.457534853183844
>>> amin(x)
6.9754969343138669
>>> ptp(x)
92.482037918869977
>>> mean(x)
57.907557231457702
>>> median(x)
58.818348186409395
>>> std(x)
26.041300224562974
2.5.0.2 Exerćı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 distribúı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 0x2a74f50 >]
>>> pl.plot(xs , ys ,label=’curva fitada ’)
[<matplotlib.lines.Line2D object at 0x2a79210 >]
>>> pl.xlabel(’x’)
<matplotlib.text.Text object at 0x2787250 >
>>> pl.ylabel(’y’)
<matplotlib.text.Text object at 0x2781c90 >
>>> pl.legend ()
>>> pl.show()
0 1 2 3 4 5
y
1.5
1.0
0.5
0.0
0.5
1.0
dados
curva fitada
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:
4 3 2 1 0 1 2 3 41.0
0.5
0.0
0.5
1.0
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( )
4 3 2 1 0 1 2 3 41.0
0.5
0.0
0.5
1.0
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ão15
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.0874989834394464
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 dispońı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
posśı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
x→x0
f(x)
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 Exerćıcios de Fixação
1. Faça uma função para a conversão de miĺı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 miĺımetros: 55,3 ; 689,2 ; 23,1 ; 98,35 ; 12,7
; 4985,22 ; 0,5432 ; 15549,13 ; 0,1
b) Converta para miĺı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 exerćıcio 2.
3. Uma análise muito importante para tratamento de água industrial é śılica solúvel
alto teor, que é uma análise espectrofotométrica. Para se realizar análises de śı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 śı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 dasaná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-
pońı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/
View publication statsView publication stats
https://www.researchgate.net/publication/307925106
	Sumário
	Primeiros Contatos
	Ambientes de Desenvolvimento
	Terminal
	Ipython
	Spyder
	Diferenças entre Python 2.x e 3.x
	Importando Módulos de Bibliotecas
	Comandos Básicos
	Sequências
	Strings
	Listas
	Funções
	Definindo Funções
	Controle de Fluxo
	Condicionais
	If - Then - Else
	Laço For
	Laço While
	Numpy
	Funções Matemáticas
	Funções Gerais
	Exercícios
	Números Complexos
	Exercícios
	Arrays
	Criando Arrays
	Exercícios
	Álgebra Linear
	Utilizando arrays como matrizes
	Exercícios:
	Produto Escalar e Vetorial
	Exemplos
	Exercícios
	Polinômios
	Exemplos
	Estatística
	Exemplos
	Exercícios
	Matplotlib
	Gráficos Simples
	Mudando Cores e Espessuras da linha
	Gráficos 3D
	Sympy
	O que Computação Simbólica
	Operações Básicas
	Substituições
	Exemplos
	Convertendo Strings em Expressões SymPy
	evalf
	lambdify
	Simplificações
	simplify
	Funções de Simplificação Polinomial
	expand
	factor
	colect
	apart
	Simplificaçõs Trigonométricas
	trigsimp
	expand_trig
	Cálculo Diferencial e Integral
	Derivadas
	Integrais
	Limites
	Exercícios de Fixação
	Referências