Python 1

Cálculo cientı́fico com Python
Software de Matemática em Engenharia
António Sousa
Laboratório de Engenharia Matemática

Departamento de Matemática
Instituto Superior de Engenharia do Porto
ats@isep.ipp.pt
06/03/2019
Resumo
Linguagens na computação
Linguagens e programas
A linguagem Python
A linguagem Python
Bases da linguagem Python
Comandos Python
Scripts e programas
Bibliotecas
Cálculo cientı́fico
Bibliotecas para cálculo cientı́fico
Biblioteca Sympy
Biblioteca Pandas
Referências
A linguagem Python Linguagens e programas
Cálculo cientı́fico A linguagem Python
Referências
ATS Cálculo cientı́fico com Python
Referências
Programas de computador
Um programa é uma sequência de comandos numa dada
linguagem com vista a realizar uma tarefa, por exemplo,
I realizar cálculos numéricos ou simbólicos;
I automatizar tarefas repetitivas;
I fornecer um navegador Web;
I fornecer uma aplicação especı́fica, etc..
Na generalidade estruturam-se da seguinte forma:
Inı́cio Entrada Processamento Saı́da Fim
Existem diversas linguagens de programação criadas para responder

a problemas genéricos ou destinadas a fins especı́ficos.
Referências
Linguagens de programação
No contexto desta apresentação, linguagem refere-se a um
conjunto de comandos de uma linguagem de programação,
convertı́vel numa sequência de instruções que o processador deve
executar.
A linguagem pode ser:
I Linguagem de máquina;
I Linguagem assembly e de baixo nı́vel
C, ...
I Linguagem de alto nı́vel
C, C++, Java, Python, ...
I Linguagem de aplicações (macros)
VBA, SPSS, ...
I Linguagem de cálculo cientı́fico
MATLAB, IDL, Maxima, ...
Referências
Compilar e interpretar
Produzir um Programa necessita de:

I editor de texto para escrever o programa;
I interpretador ou compilador para processar o programa.
Interpretar versus compilar

I Um interpretador lê os comando do programa e executa-os.
Executar o programa exige sempre o interpretador.
Maior facilidade e rapidez de elaboração.
I Um compilador traduz o código fonte para código de máquina.
Só é necessário uma vez, para gerar a aplicação.
Maior rapidez de execução.

Referências
Porquê o Python?
O Python é uma linguagem de alto nı́vel interpretada mas que
implementa uma solução mista
1. Compila o código fonte para bytecode;
2. O interpretador executa o programa pseudo-compiladado.
Maior rapidez de execução e facilidade de elaboração.
Existem duas maneiras de usar o interpretador Python:

I modo linha de comando;
I modo execução.
No modo linha de comando, as instruções são interpretados de
imediato, sendo o resultado apresentado de seguida, tal como uma
calculadora cientı́fica.
No modo execução, o interpretador é chamado para executar o
programa.
Referências
Ambiente IDE Spyder+IPython
Na prática, recorre-se a um IDE que permita usar os dois modos de

trabalho e para criar, editar e depurar os programas.
IDE Spyder (Scientific PYthon Development EnviRonment)

Ambiente muito intuitivo e bem apetrechado de facilidades que
apoiam o programador na escrita dos seus programas. Inclui
I editor de programas,
I consolas Python e IPython,
I ferramentas para gestão de pastas, de variáveis, de objetos,
etc.
I interface similar à interface do MATLAB.

Referências
Ambiente IDE Spyder+IPython
Figura: IDE Spyder

Referências
Sessão básica no IPython

A forma mais elementar de trabalhar no Python é usar a consola
IPython do Spyder.
Com o Python instalado, mas não estando instalado o Spyder,
ainda assim pode tentar:
1. Recorrer à linha de comandos do sistema. Para isso abrir um
terminal (Linha de comandos no Windows) e digitar o comando:
ipython qtconsole
2. em alternativa lançar o jupyter notebook com o comando
jupyter notebook > [New] > [Python 2]
3. ou lançar uma sessão jupyter notebook num servidor online
https://jupyter.org/try
Referências
Sessão básica no IPython
Numa consola ou notebook IPython experimentar os comandos:
In [1]: 3+7 # o cardinal inicia um comentário

In [2]: 3*7 #
In [3]: 7/3 # operações aritméticas
In [4]: 7.0/3 #
In [5]: Out[2]*Out[3] # produto das saídas 2 e 3
In [6]: _ + __ + ___ # soma os últimos 3 resultados
In [7]: 3**7 # 3 elevado a 7
In [8]: 3^7 # teste lógico ’XOR’ bit a bit
In [9]: sqrt(2) # ??
Referências
Editor do Spyder
Para um trabalho mais complexo deve-se usar um editor.
No Editor integrado do Spyder existe o marcador #%% nome da
célula que auxilia na separação do código em secções e permite a
sua execução separada.

Linguagens na computação Bases da linguagem Python
A linguagem Python Comandos Python
Cálculo cientı́fico Scripts e programas
Referências Bibliotecas
A linguagem Python

Operadores
Os operadores básicos da linguagem Python são:

Operador Descrição
+ Adição
- Subtracção
* Multiplicação
/ Divisão (real ou inteira)
// Divisão inteira
** Exponenciação
% Resto da divisão inteira
and Conjunção
or Disjunção
not Negação

Tipos de dados
O Python é uma linguagem tipificada.
De base, os tipos de dados suportados são
I numéricos:
int inteiros
long inteiros longos
float ponto flutuante (notação cientı́fica)
complex complexos com parte real e imaginária do tipo
float
I lógicos ou booleanos:
bool apenas valor False ou True
Para ver o tipo de uma variável usa-se o comando
type(objeto)

Estruturas de dados
Usam-se quando o número de dados é variável, ou de diferentes
tipos. Podem ser
str cadeia de caracteres (string)
tuple sequência formada por vários elementos (imutável)
list sequência formada por vários objetos (mutável)
dict dicionário que mapeia objetos a chaves
set conjunto de elementos não repetidos
As variáveis são criadas no momento de atribuição e o tipo é

decidido pelo interpretador ou pelo programador. Por exemplo,
para criar a variável inteira <dia> com o valor <18>, tem-se
dia = 18

Exemplo
Na consola IPython do Spyder, ou no Editor, experimente

x=5/2 # x = 2
y=int(7.0/2) # y = 3
z=complex(x,y) # z = 2+3j
l=[type(x), type(z)] # tipos de x e z
t=tuple(l) # um tuplo = l
a, b, c = 6, 5, 4 # atribuição múltipla
a, c = c, a # troca c por a
x = (b+c)/a # operar com variáveis
x += 3 # x = x + 3
x *= 2 # x= x * 2
d=dict({’a’:6,’b’:5,’c’:4})
d[’b’] # elemento chave ’b’

Variáveis ou objetos?
Na linguagem Python tudo são objetos que possuem valor(es),
funções e métodos, listados com o comando
dir(objeto)
e acedem-se com os comandos

objeto.método
objeto.função()
Exemplo
z=(2+3j) # z é complexo
w=z.conjugate() # w é conjugado de z
c=abs(z) # módulo de z
x=z.real # parte real de z
Nota: nome do objeto seguido de ponto e teclar [TAB] vai listar os parâmetros
associados ao objeto.
Condições
As condições utilizam os operadores de comparação entre

designações.
Seguem-se alguns exemplos
5 < 5 # < menor
5 <= 5 # <= menor ou igual
5 > 5 # > maior
5 >= 5 # >= maior ou igual
5 == 10/2.0 # == igual
5 != 5 # != diferente
5 is 10/2. # is usa o ID do objeto
5 is not 10/2.

Tuplos
Tuplos são objetos imutáveis formados por sequências de dados de

qualquer tipo.
Exemplo
t=(1,’lmat1’,complex(12,5),(1,2),[3,4])
t[0] # 1o objeto tem índice 0
t[-1] # último objeto
t[1:3] # alguns elementos de t
len(t) # número de elementos em t
1 in t # 1 pertence a t?
t + (5,) # + para concatenar tuplos
t*2 # * para concatenar cópias
t[0]=5 # atribuição não permitida!

Listas
As listas são sequências formadas por conjuntos de dados

mutáveis, isto é, as listas podem ser alteradas depois de criadas.
Exemplo
s=[1,’lmat1’,complex(12,5),(1,2),[3,4]]
s[0] # 1o objeto: ordem 0
s[-1]=’fim’ # alterar último
s[1:3] # dois elementos
len(s) # número de elementos
1 in s # 1 pertence a s?
s + [12,’end’] # concatenar listas
s.append(15) # incluir elemento
s[0]=5 # atribuição permitida!

Índices e ordem dos elementos
Algumas regras a ter em atenção acerca dos ı́ndices no Python:

I o 1o elemento tem o ı́ndice 0, o 2o tem o ı́ndice 1 e assim
sucessivamente;
I os ı́ndices podem se abordados do fim para o inı́cio através do
uso de ı́ndices negativos, a começar em -1;
I podem ser definidos como blocos, na forma
[início:fim+1:passo]. Se não for definido o início, será
considerado 0. Se não for definido o fim+1, será considerado
o número de elementos do objeto. Se não for definido o
passo, será considerado 1.
É possı́vel mostrar a ordem dos elementos invertida, usando ı́ndices
e passo negativos.

Strings
Cadeias de carateres delimitadas por aspas (”...”) ou plicas (’...’).

Usar aspas triplas para strings com várias linhas.
Strings com sı́mbolos internacionais precedem-se de um u.
Comandos dedicados à entrada e saı́da de informação

raw_input(’mensagem’) # string
print(’mensagem’) # mostra mensagem
Exemplo
a=raw_input(’Qual o seu nome? ’)
b=int(raw_input(’e a sua idade? ’))
msg=a+u’, a sua idade é ’+str(b)
print(msg)

Blocos de código
Um bloco de código é um conjunto de comandos precedido de uma

instrução identificadora e ”:”, sendo a sua indentação o elemento
marcador do conjunto de instruções que forma o bloco.
Os blocos de código em ciclos for ou while e controlo de fluxo

if-elif-else são obrigatoriamente indentados.
Os blocos de instruções que definem novas funções ou classes

também têm de ser indentados.

Ciclos for e while
Sintaxe do ciclo ’for’

for <contador> in <intervalo>:
bloco de código do ciclo
em uma ou várias linhas indentadas
O ciclo tem um contador associado a um intervalo de valores,

normalmente um ı́ndice.
O intervalo obtém-se, por exemplo, com a função range().
A sintaxe da função range() é
range(end)
range(first, end)
range(first, end, step)
Em alternativa, podem utilizar-se iteradores.

Ciclos for e while

Exemplo > usar o editor
a=[5,4,3,2,1.2,’zero ?’]
for p in a:
print(p)
# outra alternativa
for i in range(len(a)):
print(a[i])
# com iterador
b=iter(a)
for i in b:
print(i)
# ou ainda de outra forma
for i, j in enumerate(a):
print(i,j)
Nota: x=iter(seq) converte a sequência seq no iterador x. A função
x.next() devolve o valor atual e move o ponteiro para o elemento seguinte.
Ciclos for e while
Sintaxe do ciclo ’while’

while <condição>:
bloco de comandos a executar
se a condição for verdadeira
Exemplo
x=1
while x<10:
print(x)
x=x*2
print(str(x)+u’ está fora do ciclo’)

Controlo de fluxo
Sintaxe de controlo de fluxo ’if’

if <condição_1>:
bloco de comandos
se a condição_1 é verdadeira
elif <condição_2>:
bloco de comandos
se condição_2 é verdadeira
...
else:
bloco de código se
todas as condições são falsas

Controlo de fluxo
Exemplo
a=int(raw_input(’indique um inteiro entre 1 e 10:’))
if a<=10 and a>=5:
print(str(a)+’ tem valor inferior a uma dezena’)
elif a<5:
print(str(a)+’ tem valor menor que 5’)
else:
print(’indicou um inteiro maior que 10’)

Ciclos interrompidos
Nos ciclos o comando break força a saı́da imediata e continue
passa de imediato à iteração seguinte.
Exemplo
for i in range(2,100):
x=2; flag=True
while x*x<=i:
if float(i)/x==int(i/x):
flag=False
break
x=x+1
if flag:
print(’\n’+str(i)+u’ é primo’+’\n’)
continue
print(i)
Definir novas funções

Para definir uma nova função usa-se o comando def com a
seguinte sintaxe
def nome_da_função(argumentos):
””” descrição ou comentário ”””
«bloco de código»
return resultados
Exemplo
def fact(n):
””” calcula o fatorial de n ”””
if n==0:
res=1
else:
res=n*fact(n-1) # função recursiva n!=(n-1)!
return res

Comandos Python
I O Python tem por base um conjunto reduzido de instruções e

funções.
I De seguida listam-se esses comandos e descreve-se
sucintamente a sua ação.
I Em alguns casos, exemplifica-se o seu uso com um exemplo de
aplicação.

Comandos de entrada/saı́da
raw input(s) Mostra mensagem s e aguarda pelo operador.

input(s) Mostra mensagem s e aguarda pelo operador;
equivalente a eval(raw_input(s)).
open(f, m) Abre ficheiro f no modo m para leitura/escrita (r/w).
print s Mostra a mensagem s na consola.
Para mensagens mais complexas é conveniente usar a função

print(.).
Para isso importe-a com comando
from __future__ import print_function

Comandos de entrada/saı́da
Exemplo
nome=raw_input(’Indique o seu nome:’)
idade=input(’Indique a sua idade:’)
with open(’test.txt’,’w’) as f:
f.write(’Nome: ’ + nome + ’\n’)
f.write(’Idade: ’ + str(idade) + \n’)
f = open(’test.txt’,’r’)
for line in f:
print(line, end = ’ ’)

Funções booleanas
all(x) Verdade se todos os elementos de x são verdadeiros.

any(x) Verdade se algum dos elementos de x é verdadeiro.
bool(x) Converte x para booleano

Funções matemáticas
abs(x) Valor absoluto de x
cmp(x,y) (-1) se x < y, zero se x = y e (+1) se x > y.
complex(s) Converte s para complexo.
complex(x,y) Complexo z = x + y j.
divmod(x,y) Divisão e resto da divisão inteira de x por y.
eval(s) Avalia a expressão s.
float(x) Variável vı́rgula flutuante.
int(x) Variável inteira.
max(iter) Máximo dos elementos do iterador.
min(iter) Mı́nimo dos elementos do iterador.
pow(x,y) xy ; o mesmo que x ∗ ∗y.
sum(iter) Soma dos valores do iterador.
round(x,n) Arredonda x para n casas decimais.
Funções para listas, tuplos, etc.
len(x) Número de elementos de x.

list(x) Lista com todos os elementos de x.
reversed(x) Elementos da sequência x pela ordem inversa.
sorted(x) Lista ordenada dos valores de x.
tuple(x) Tuplo constituı́do pelos elementos de x.

Funções geradoras de iteradores
enumerate(s) Iterador com dois elementos, ı́ndice e valor.

range(i,f,p) Sequência de valores de i até f − 1 de passo p.
xrange(.) Iterador semelhante a range, ...
zip(x,y,...) Reorganiza os valores de x, y, ..., por tuplos.

Strings
chr(x) Carácter ASCII.

ord(c) Código ASCII ou Unicode do carácter c.
repr(x) Representação do objecto x como impresso.
str(x) Converte x para string.
hex(n) Representação hexadecimal do número inteiro n.
unichr(n) Carácter Unicode de código n.

Comandos funcionais
iter(x) Iterador com os elementos de x.

filter(f,x) Todos os elementos do iterador x para os quais a
função f é verdadeira.
map(f,x,...) Aplica f com o valor dos iteradores x, ...
reduce(f,x) Calcula f para os dois primeiros elementos de x e
depois o resultado com o valor seguinte, até obter o
resultado final.
lambda x:f Define a função anónima f (pode ser multivariável).
Exemplo
y=iter(range(100))
z=filter(lambda x:x*(x>=5 and x<=10),y)
reduce(lambda x,y:x+y,z)

Comandos de ambiente
dir(x) Lista os atributos do objecto x.

globals() Tabela de sı́mbolos global.
help(c) Ajuda sobre o comando c.
locals() Tabela de sı́mbolos local.
reload(lib) Volta a importar a biblioteca lib.

Escrever programas
Um programa ou script é um conjunto de comandos, ordenados

por ordem de execução, com o objetivo de resolver um problema.
Recorre-se a um editor para elaborar o programa e executa-se com
o comando python NomePrograma.py
Boas práticas na estruturação de um programa Python
1. Secção inicial para configurar o ambiente
2. Secção de importação de bibliotecas
3. Secção de novas funcionalidades
4. Corpo principal de programa

Recursos adicionais
... e se a função pretendida não está definida na linguagem base?

Procura-se uma biblioteca que a contenha!
As bibliotecas são carregadas explicitamente antes de serem usadas.
Os comandos para carregamento ou importação de bibliotecas são:
import «biblioteca»
import «biblioteca» as «lib»
from «biblioteca» import *
from «biblioteca» import «função»
from «biblioteca» import «função» as «função2»

Bibliotecas padrão
O Python vem com um conjunto de bibliotecas, designado de

bibliotecas padrão, as quais executam tarefas essenciais não
consideradas na implementação base.
Algumas dessas bibliotecas padrão são:
Cálculo: math, cmath, random;
Sistema: sys, os;
Tempo: time, datetime, timeit.

Bibliotecas padrão: exemplo 1

# -*- coding: utf-8 -*-
from __future__ import division
import os, time, math, random # importa as bibliotecas
import sys as sistema # importa sys >> sistema
# escreve algumas informações do sistema em uso

print(’SO: ’,os.name) # apresenta o nome do SO
print(’path: ’,(sistema.path)[:3]) # pastas acessíveis
# ciclo for: determina tempo de execução

n=random.randint(10**6,10**7) # no execuções
inicio=time.time() # tempo atual
print(’n=’,n)
for i in range(n):
x=i/360
y=math.sin(x)
fim=time.time() # tempo atual
# tempo de execução do ciclo

print(u’\nTempo: ’,round(fim-inicio,2),’s’)
SAÍDA
SO: nt
path: [’’, ’D:\\LMAT1\\Scripts\\mpmath’, ’D:\\LMAT1\\Scripts\\LabMat1_Lib’]
n= 1329699
Tempo: 1.72 s

Bibliotecas padrão: exemplo 2

# -*- coding: utf-8 -*-
"""
Cálculo com Python
@author: António Sousa, 18 de Abril de 2018
"""
from math import *
#%% Novas funções

def clc():
"""
Clear screen.\n
Only works inside of IPython console.
"""
print(chr(27) + "[2J");
#%% Corpo do programa

clc()
X=[x*pi/19 for x in range(20)]
print(’-’*44)
print(’|{0:>5} | {1:>9} | {2:>9} | {3:>9} |’.format(’i’,’x’,’sin(x)’,’tan(x)’))
print(’-’*44)
for i,x in enumerate(X):
print(’|{0:5d} | {1:9.4f} | {2:9.4f} | {3:9.4f} |’.format(i,x,sin(x),tan(x)))
print(’-’*44)
#%% fim

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Bibliotecas fundamentais
Para complementar as bibliotecas padrão, existe ainda um vasto

conjunto de bibliotecas destinadas ao cálculo cientı́fico ou a outros
fins.
Dentre estas são de realçar:
NumPy Novas estruturas de dados e cálculo numérico
SciPy Conjunto de bibliotecas similares às toolboxes do
MATLAB
Matplotlib Capacidades gráficas
Pylab Emula alguns comandos do MATLAB
Sympy Cálculo simbólico
Pandas Análise de dados

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Numpy
NumPy acrescenta capacidades de cálculo numérico e matricial;

destacam-se:
I arrays multidimensionais com tipos de dados homogéneos
I funções para geração e manipulação de matrizes (matrizes
identidade, nula, etc. e redimensionar, transpor, concatenar,
...)
I operações matemáticas elemento a elemento, matriciais, etc.
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Scipy
Baseia-se no NumPy e acrescenta um conjunto de bibliotecas para

cálculo cientifico; destacam-se:
scipy.io Gestão de ficheiros de dados,
scipy.special Funções especiais,
scipy.linalg Operações de álgebra linear,
scipy.interpolate Interpolação,
scipy.signal Processamento de sinal,
scipy.fft Transformada rápida de Fourier,
scipy.ndimage Processamento de imagem multidimensional,
scipy.integrate Integração numérica,
scipy.stats Funções estatı́sticas.

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Matplotlib e Pylab
Matplotlib acrescenta ao NumPy/SciPy capacidades gráficas ao

género do MATLAB.
Pylab meta-package que inclui as bibliotecas NumPy,
SciPy, e Matplotlib
implementa comandos similares ao MATLAB.
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Numpy-Matplotlib-Pylab - Exemplo 1.1
# -*- coding: utf-8 -*-

from pylab import *
# arrays: dados multidimensionais

A = array([1, 2, 3]) # array 1D com uma lista
B = array([[1, 2, 3],[4, 5, 6],[7, 8, 9.]]) # 2D (3 listas)
C = array([B, B]) # 3D array (pilhas 2D)
B.shape # tamanho das dimensões
C.shape
C.ndim # número de dimensões
C.dtype # tipo de dados

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
# operações elemento a elemento e matricial

M = B*B # * elemento a elemento
print(M)
print(dot(B,B)) # * matricial
print(matrix(B)**2)
# arrays especiais
print(zeros((2,2)))
print(ones((3,3)))
print(eye(3))
print(diag([[1, 2, 3],[4,5,6]]))
print(diag(B))
print(rand(3,4))
print(tile(rand(3,1), (1, 5)))
print(M[2,1])
print(M[:2,1])
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
# arrays de passo definido/gráficos

x=arange(0,10,0.1)
print(x)
# arrays de comprimento definido

x=linspace(0,10,101)
print(x)
# operações vetorizadas com funções

Y=sin(x)*cos(x)+exp(-x**2)
figure()
plot(x,Y,’-r’)
xlabel(r’$x$’)
ylabel(r’$y$’)
title(r’$f(x)=sin(x) \cdot cos(x)+exp\left(-x^2\right)$’)
show()

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências

# 3D
f=lambda x,y:5*exp(-x**2-y**2)-10*exp(-(x-2)**2-(y+3)**2)
xq,yq=meshgrid(linspace(-5,5,1000),linspace(-5,5,1000))
z=f(xq,yq)
figure()
imshow(z,cmap=cm.gray);
axis(’image’);colorbar()
show()
figure()
contourf(xq,yq,z,50);
axis([-5,5,-5,5]);colorbar()
xlabel(’x’)
ylabel(’y’)
show()
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
#%% importar bibliotecas necessárias

import numpy as np
from pylab import *
from scipy.stats import shapiro,describe,linregress
x=np.arange(0,100,5)
y=2+0.5*x
yr=y+np.random.normal(0,3,len(x))
figure()
plot(x,y,’-r’,x,yr,’.b’)
show()

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
print(describe(yr))
teste,pvalue=shapiro(yr)
print(’Teste Shapiro-Wilk: p_value=’,pvalue)
m,b,r,p,stderr=linregress(x,yr)
print(u’Regressão linear\nm=’,m,’\nb=’,b,
’\nr=’,r,’\np_value’,p,’\nerro=’,stderr)
figure()
plot(x,y,’-r’,x,m*x+b,’-g’,x,yr,’.b’)
show()
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Sympy
Sympy é uma biblioteca de cálculo simbólico (CAS) Nas suas

capacidades inclui-se, por exemplo
I Operações básicas com expressões
Substituição, conversão, avaliação, definição de funções
lambda, etc.
I Visualização em formato matemático e gráfica
I Simplificação de expressões
I Cálculo simbólico
Derivadas,integrais, limites, séries, etc.
I Resolução exata e aproximada de equações.

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
CAS - 1.1 Activar ambiente simbólico

# bibliotecas carregadas para workspaces separados

import sympy as sp
# bilbiotecas carregadas para o ambiente de trabalho

from pylab import *
# substitui comand PRINT para objetos matemáticos

from IPython.display import display
# necessário para ativar display

# usar opção latex; <<use_latex=’matplotlib’>> se Latex não funcionar
sp.init_printing(wrap_line=True)
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
CAS - 1.2 Variáveis e expressões
# DEFINIÇÃO DE VARIÁVEIS SIMBÓLICAS E DOMÍNIO

x,y,t = sp.symbols(’x,y,t’, real=True)
# DEFINIÇÃO DE FUNÇÕES ANÓNIMAS

f=sp.Lambda(x,sp.ln(5/sp.sqrt(2+x**2)))
display(sp.Eq(sp.Symbol(’f(x)’),f(x)))
sp.plot(f(x)); # gráfico de f
print(’Zeros de f’)
fzeros=sp.solve(sp.Eq(f(x),0),x)
display(fzeros)

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
CAS - 1.3 Funções e gráficos
#%% DEFINIÇÃO DE FUNÇÕES POR RAMOS E COMPOSTAS

g=sp.Lambda(t,sp.Piecewise((0,t<0),(t,t<1),(1,t>=1)))
display(sp.Eq(sp.Symbol(’g(t)’),g(t)))
display(sp.Eq(sp.Symbol(’gof(t)’),g(f(t))))
pt=sp.plot((f(x),(x,-10,10)),(g(f(x)),(x,-10,10)),show=False)
pt[0].line_color=’r’; pt[0].label=’f’
pt[1].line_color=’k’; pt[1].label=’gof’
pt.ylabel=’y’; pt.ylabel=’y’
pt.title=u’Gráficos de $f$ e $gof$’
pt.legend=True
pt.show()
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
CAS - 1.4 Cálculo
# LIMITES DE EXPRESSÕES OU FUNÇÕES

expr=sp.sin(2*x)/(sp.exp(3*x)-1)
display(sp.Eq(sp.Limit(expr,x,0,’+’),sp.limit(expr,x,0,’+’)))
# DERIVADAS
d1f=sp.diff(f(x),x)
d2f=sp.diff(f(x),x,2)
display(sp.Eq(sp.Derivative(f(x),x),d1f))
display(sp.Eq(sp.Derivative(f(x),x,2),d2f))
display(sp.Eq(sp.Eq(sp.Derivative(f(x),x,2),d2f),sp.simplify(d2f),evaluate=False))
# INTEGRAIS
intg=sp.Integral(f(x),(x,-1,5))
display(sp.Eq(intg,intg.doit()))

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
CAS - 1.5 Funções periódicas
#%% Exemplo de aplicação a séries de Fourier

t,tau,T = sp.symbols(’t, tau, T’, real=True)
n=sp.symbols(’n’, integer=True,positive=True)
m=sp.Lambda((t,tau,T),t-T*sp.floor((t-tau)/T))
# definir h(t)=0 se -1<=t<0, t se 0<=t<1, de período T=2

T0=2; tau0=-1
h=sp.Lambda(t,g(m(t,tau0,T0)))
sp.plot(h(t),(t,-2*T0+tau0,2*T0+tau0));
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
CAS - 1.6 Séries de Fourier
# cálculo dos coeficientes de Fourier

a0=sp.Rational(2,T0)*sp.integrate(g(t),(t,-1,1))
an=sp.Rational(2,T0)*sp.integrate(g(t)*sp.cos(n*sp.pi*t),(t,tau0,tau0+T0))
bn=sp.Rational(2,T0)*sp.integrate(g(t)*sp.sin(n*sp.pi*t),(t,tau0,tau0+T0))
S=a0/2+sp.Sum(an*sp.cos(n*sp.pi*t)+bn*sp.sin(n*sp.pi*t),(n,1,sp.oo))
display(S)

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
CAS - 1.7 Séries de Fourier
# ver gráficos da soma parcial e de h

N=3
SN=sp.Rational(a0,2)+sp.summation(an*sp.cos(n*sp.pi*t)+bn*sp.sin(n*sp.pi*t),(n,1,N))
pt=sp.plot((h(t),(t,-2*T0+tau0,2*T0+tau0)),(SN,(t,-2*T0+tau0,2*T0+tau0)),show=False);
pt[0].line_color=’r’; pt[0].label=’h’
pt[1].line_color=’g’; pt[1].label=r’$S_6$’
pt.ylabel=’y’; pt.ylabel=’y’
pt.title=u’Gráficos de $h$ e $S_6$’
pt.legend=True
pt.show()
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Pandas
Pandas é uma biblioteca para análise de dados estruturados em
forma tabular (DataFrames). Trabalha integrada com o scipy e
pylab.
Eis um exemplo:
# -*- coding: utf-8 -*-
import pandas as pd
from pylab import *
excel_file="FEMURS_ALL_MEASURES.xlsx"
sheetN=’X_AUT’
sheet=pd.read_excel(excel_file,
sheetname=sheetN,header=0,
skiprows=[1],index_col=0)
print(sheet)
print(sheet[’AGE’].describe()) # estatística

A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Pandas
x=array(sheet[’STA’]) # converter para array

y=array(sheet[’M60’])
g=array(sheet[’SEX’])
figure(1)
gen=unique(g) # classes
cor=[’r’,’b’]
for i,j in enumerate(gen):
# regressão linear por classes
m,b = polyfit(x[g==j],y[g==j], 1)
plot(x[g==j],y[g==j], cor[i]+’o’,
x, m*x+b, ’--’+cor[i])
xlabel(’STA/mm’)
ylabel(’M60/mm’)
legend(gen)
A linguagem Python
Biblioteca Sympy
Biblioteca Pandas
Referências
Processamento de Imagem
# -*- coding: utf-8 -*-
from pylab import *
from cv2 import VideoCapture # computer vision
from skimage import filters # proc. imagem
camera = VideoCapture(0) # ativa a porta da câmara
s=raw_input(’Press Enter to capture’)
flag, image = camera.read()
flag, image = camera.read() # regista a 2a frame
RGB=image[:,:,[2,1,0]] # BGR > RGB
del(camera) # fecha a porta
cinza=uint8(mean(RGB,2)) # processa imagem
bw=cinza>filters.threshold_otsu(cinza)
edges=filters.sobel(bw)
figure(1) # mostra resultados
subplot(2,2,1); imshow(RGB);axis(’off’)
subplot(2,2,2); imshow(cinza,cmap=cm.gray);axis(’off’)
subplot(2,2,3); imshow(bw,cmap=cm.binary);axis(’off’)
subplot(2,2,4); imshow(edges,cmap=cm.binary);axis(’off’)
imsave(’edges.png’,edges)
show()
A linguagem Python
Referências
Referências
A linguagem Python
Referências
Referencias
1] Python Software Fundation

https://docs.python.org/2/contents.html
15/04/2018.
2] Scipy - Numpy - Matplotlib - Pandas - IPython - Sympy

https://www.scipy.org/
15/04/2018.
3] Sympy
http://docs.sympy.org/latest/index.html
15/04/2018.

A linguagem Python
Referências
Obrigado...

Python 1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Python 1

Enviado por

Direitos autorais:

Formatos disponíveis

Cálculo cientı́fico com Python

Software de Matemática em Engenharia

Laboratório de Engenharia Matemática

ATS Cálculo cientı́fico com Python

Na generalidade estruturam-se da seguinte forma:

Inı́cio Entrada Processamento Saı́da Fim

Existem diversas linguagens de programação criadas para responder

Produzir um Programa necessita de:

Interpretar versus compilar

ATS Cálculo cientı́fico com Python

Existem duas maneiras de usar o interpretador Python:

Ambiente IDE Spyder+IPython

Na prática, recorre-se a um IDE que permita usar os dois modos de

IDE Spyder (Scientific PYthon Development EnviRonment)

ATS Cálculo cientı́fico com Python

Ambiente IDE Spyder+IPython

Figura: IDE Spyder

Sessão básica no IPython

Sessão básica no IPython

Numa consola ou notebook IPython experimentar os comandos:

In [1]: 3+7 # o cardinal inicia um comentário

ATS Cálculo cientı́fico com Python

ATS Cálculo cientı́fico com Python

ATS Cálculo cientı́fico com Python

Linguagens na computação Bases da linguagem Python

Os operadores básicos da linguagem Python são:

ATS Cálculo cientı́fico com Python

ATS Cálculo cientı́fico com Python

Linguagens na computação Bases da linguagem Python

As variáveis são criadas no momento de atribuição e o tipo é

ATS Cálculo cientı́fico com Python

Na consola IPython do Spyder, ou no Editor, experimente

ATS Cálculo cientı́fico com Python

Linguagens na computação Bases da linguagem Python

e acedem-se com os comandos

As condições utilizam os operadores de comparação entre

ATS Cálculo cientı́fico com Python

Linguagens na computação Bases da linguagem Python

Tuplos são objetos imutáveis formados por sequências de dados de

ATS Cálculo cientı́fico com Python

As listas são sequências formadas por conjuntos de dados

ATS Cálculo cientı́fico com Python

Linguagens na computação Bases da linguagem Python

Índices e ordem dos elementos

Algumas regras a ter em atenção acerca dos ı́ndices no Python:

ATS Cálculo cientı́fico com Python

Cadeias de carateres delimitadas por aspas (”...”) ou plicas (’...’).

Comandos dedicados à entrada e saı́da de informação

ATS Cálculo cientı́fico com Python

Linguagens na computação Bases da linguagem Python

Um bloco de código é um conjunto de comandos precedido de uma

Os blocos de código em ciclos for ou while e controlo de fluxo

Os blocos de instruções que definem novas funções ou classes

ATS Cálculo cientı́fico com Python

Ciclos for e while

Sintaxe do ciclo ’for’

O ciclo tem um contador associado a um intervalo de valores,

Em alternativa, podem utilizar-se iteradores.

ATS Cálculo cientı́fico com Python

Linguagens na computação Bases da linguagem Python

Ciclos for e while

Ciclos for e while

Sintaxe do ciclo ’while’

from future import print_function

# -- coding: utf-8 --