Python para oceanógrafos/Imprimir

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa


Índice

Capa

Python para Oceanógrafos
Sea water Virgo.jpg

Prefácio

O uso de ferramentas computacionais para a aquisição, visualização, análise e interpretação de dados científicos é imprescindível para as ciências dos mares devido o enorme volume de informação disponível. Neste contexto, Python aparece como uma ferramenta moderna, flexível e de baixo custo. O objetivo deste guia é dar uma breve introdução à linguagem de programação Python aplicada à análise de dados oceanográficos através de exemplos práticos e realistas.

Python é uma linguagem de programação de alto nível de uso geral, interpretada, orientada a objetos, cuja filosofia de design enfatiza a leitura de código. Lançada por Guido van Rossum em 1991, possui atualmente um modelo de desenvolvimento comunitário, aberto e gerenciado pela organização sem fins lucrativos Python Software Foundation (PSF). Python não é uma linguagem específica para análise de dados ou estatística. É uma linguagem bastante flexível que pode ser utilizada em diversas aplicações como Internet, processamento de imagens, jogos, etc. Existem inúmeras bibliotecas disponíveis para Python que estendem as funcionalidades da linguagem, dentre elas para uso científico. Aqui focaremos em algumas aplicações oceanográficas.

Planilhas eletrônicas convencionais são ferramentas importantes para a análise de dados e estatística. Entretanto, com um volume de dados extenso a automação no tratamento destes dados pode ser limitada ou até mesmo impossível em tais planilhas. É importante salientar que, independente da ferramenta utilizada, todas elas possuem limitações quanto a sua aplicação a determinados problemas, e Python não é exceção.

A elaboração deste guia foi motivada pela vontade de difundir a linguagem Python como alternativa de qualidade, flexível, livre e gratuita a programas para análise de dados científicos comerciais, como MATLAB® e IDL® por exemplo. Todo o conteúdo é baseado em informação amplamente disponível na Internet, tanto nas páginas oficiais do Python quanto nas bibliotecas utilizadas e em fóruns específicos. Quando possível, referências importantes serão indicadas.


Prerequisitos[editar | editar código-fonte]

Este guia não prevê quaisquer conhecimentos prévios em programação ou na linguagem Python. No entanto um curso introdutório à computação certamente traz grandes benefícios, principalmente quanto à lógica de programação. Think Python dá uma boa introdução de como pensar como um cientista da computação utilizando Python de maneira simples, construtiva e intuitiva. Outra boa referência para desenvolvedores mais experientes é Dive into Python.

Muitos conceitos de programação serão omitidos para manter o texto conciso. Ao invés de descrever estes conceitos, exemplos passo-a-passo ilustram a funcionalidade de diversas aplicações na análise de dados oceanográficos de forma prática e construtiva. Quando apropriado, referências para consulta são indicadas.

Hoje em dia é imprescindível algum conhecimento básico de inglês, principalmente na compreensão de textos. As próprias linguagens de programação são baseadas em inglês e seus principais recursos de documentação disponíveis na Internet são neste idioma. Podem ocorrer casos em que a documentação é internacionalizada e também disponível em português, mas assume-se do leitor algum conhecimento básico de leitura de textos no idioma da Rainha ou do Tio Sam para consultar as referências aqui citadas com naturalidade.

Os exemplos[editar | editar código-fonte]

Os códigos de exemplo de cada seção são escritos em forma de tutorial, encorajando a construção de aplicativos em etapas e para compreender como os algoritmos funcionam. Os exemplos devem ser acompanhados passo-a-passo e executados de maneira interativa para que você compreenda o funcionamento. Os algoritmos apresentados são simples e podem ser facilmente estendidos de diversas formas de acordo com as particularidades de cada tipo de análise.

Todos os códigos fonte utilizados estão disponíveis em formato digital na página Internet deste guia. Entretanto, recomenda-se que o código seja digitado manualmente para a familiarização com a sintaxe da linguagem e para melhor fixação dos conceitos apresentados.

Porque Python?[editar | editar código-fonte]

Existem inúmeros motivos para se aprender a programar em Python e mais tantos para não se aventurar nela. A seguir são apresentados alguns dos motivos para iniciar-se nesta linguagem de programação.

Conciso. Código escrito em linguagens dinâmicas, como Python, tende a ser menor que código escrito em outras linguagens `mainstream'. Ou seja, há menos digitação ao testar os exemplos. Mais importante que escrever menos, código sucinto também simplifica a assimilação do algoritmo na mente para realmente compreender seu funcionamento.

Fácil de ler. Pessoas com experiência de programação em outras linguagens são capazes de ler código em Python e compreender o que ele deve fazer.

Extensível. Por padrão, Python vem com inúmeras bibliotecas que estendem a funcionalidade da linguagem, incluindo aquelas para funções matemáticas, manipulação de texto e conexão com a Internet. As demais bibliotecas utilizadas neste guia, como para manipulação de dados e geração de gráficos, são livres e simples de baixar, instalar e utilizar.

Interativo Ao trabalhar com um exemplo, é útil experimentar as funções enquanto elas são escritas, sem ter de escrever outro programa apenas para teste. Python é capaz de executar tanto programas diretamente da linha de comando quanto chamar funções, criar objetos e testar pacotes de forma interativa.

Múltiplos paradigmas. Python suporta estilos de programação orientados a objetos, procedurais ou funcionais.

Múltiplas plataformas e livre. Python possui uma única implementação de referência para as principais plataformas disponíveis e é livre e gratuito para todas elas. Os códigos descritos neste guia funcionam nas plataformas Windows, Linux e Mac sem quaisquer modificações.

Alternativas[editar | editar código-fonte]

Python não é a única opção de código livre ou gratuita para análise de dados. Qualquer linguagem é capaz de criar uma aplicação e solucionar os problemas que desejamos. No entanto, a melhor escolha depende do esforço necessário para tal solução e a sensação de sucesso obtida com ela. Uma lista com alternativas comerciais e livres pode ser encontrada na página da Wikipédia. Dentre as alternativas gratuitas disponíveis, destacamos as seguintes:

  • Octave. É uma linguagem computacional desenvolvida para computação matemática e compatível com MATLAB®. Possui uma interface em linha de comando para a solução de problemas numéricos, lineares e não-lineares. Criado por John W. Eaton, faz parte do projeto GNU.
  • Scilab. Software científico para computação numérica semelhante ao MATLAB. Ele fornece um poderoso ambiente computacional aberto para aplicações científicas. Atualmente o projeto é mantido pelo Scilab Consortium.
  • R. Linguagem e ambiente de desenvolvimento integrado para cálculos estatísticos e representações gráficas. Foi criada originalmente por Ross Ihaka e por Robert Gentleman. R é uma linguagem e ambiente similar ao S. Embora com importantes diferenças, muitos códigos escritos para S rodam inalterados em R.
  • GDL. Implantação livre e código aberto da linguagem de dados interativa IDL®.
  • Ocean Data View (ODV). Pacote integrado para a exploração, análise e visualização de perfis ou sequencias de dados oceanográficos ou geo-referenciados.

Visão geral[editar | editar código-fonte]

Este guia foi dividido em cinco partes para servir como base para um minicurso introdutório à linguagem Python aplicado à oceanografia e com duração de quatro dias. Cada parte é motivada por exemplos de aplicações reais que de fácil compreensão e adaptação.

  • Capítulo 1, Engatinhando. Dá instruções de como instalar e executar Python pela primeira vez e explica como executar alguns comandos básicos e um pouco sobre tipos de variáveis. As instruções dadas neste capítulo devem ser seguidas antes do início do curso, para garantir que as necessidades técnicas mínimas sejam satisfeitas e que cada participante tenha todos os aplicativos necessários instalados.
  • Capítulo 2, Primeiros passos. Introduz o conceito de funções e bibliotecas. Demonstra operações aritméticas e estatísticas básicas como soma, produto, exponenciação, mínimo, máximo, média e desvio padrão.
  • Capítulo 3, Juntando os pedaços. Ilustra os conceitos de operadores lógicos e condicionais e também iterações. Começa a trabalhar com um volume de dados maior e demonstra como carregar e salvar dados de arquivos. Visualiza estes dados pela primeira vez.
  • Capítulo 4, Avançando. Mostra exemplos de tratamento básico de dados como média móvel e representações gráficas mais elaboradas.
  • Capítulo 5, Fluência. Demonstra recursos mais avançados como análise espectral através da transformada de Fourier e visualização de mapas.

Contribuições[editar | editar código-fonte]

Referências

Pilgrim, Mark. Dive into PythonApress, 2004. 413 p.

Downey, Allen. Think Python: How to think like a computer scientist. Green Tea Press, 2008. 214 p.

Engatinhando

Instalação[editar | editar código-fonte]

A primeira coisa que você deve fazer antes escrever seu primeiro programa em Python é instalá-lo em seu computador. As distribuições Linux mais populares já vêm com Python instalado por padrão. O Mac OS em suas versões mais recentes também possui uma versão instalada. Entretanto, se você utiliza Windows, terá que instalar o Python em seu computador. Há diversas maneiras simples para instalá-lo e na maioria das vezes muito bem documentadas. Acesse o sítio Internet python.org, procure pelas instruções de instalação e siga-as. Não se esqueça também de instalar as bibliotecas utilizadas ao longo deste guia, listadas mais adiante.

Para instalação das bibliotecas, uma das ferramentas disponíveis para essa finalidade, é o pip (pip installs packages)[1] que permite a instalação e a manutenção dos módulos instalados, com um simples comando: pip install nome_da_biblioteca .

Outra indicação para uso do Python na linha de comando, é a interfácie interativa do Python através do Ipython[2], permitindo facilidades como autocompletar e teclas de atalho para funções.

Se você não quiser aventurar-se na instalação individual do Python e as principais bibliotecas utilizadas neste guia, recomendamos uma alternativa: Enthought Python Distribution. É uma distribuição de Python gratuita para fins não comerciais que vem com uma série de bibliotecas e ferramentas instaladas.


Lógica de programação[editar | editar código-fonte]

O objetivo deste guia não é transformá-lo em um guru em programação, mas introduzir conceitos importantes de uma ferramenta para análise de dados oceanográficos. No entanto é necessário desenvolver uma forma de pensar e organizar as ideias de modo a traduzi-las em uma linguagem computacional. Esta forma de pensar combina elementos matemáticos, de engenharia e das ciências naturais. Assim como os matemáticos, cientistas da computação utilizam linguagens formais para denotar ideias (principalmente cálculos computacionais). Como os engenheiros, eles criam coisas, montam componentes para formar sistemas e avaliam os benefícios de alternativas. Como cientistas, eles observam o comportamento de sistemas complexos, formam hipóteses e testam previsões (Downey, 2008).

Uma das habilidades mais importantes a serem desenvolvidas é a capacidade de solucionar problemas de maneira lógica. Mas, para solucioná-los, é preciso saber formular estes problemas, usar sua criatividade para encontrar soluções e expressar estas soluções de maneira clara e acurada.

A forma mais simplificada de se ver um programa é considerá-lo uma sequência de instruções que especificam como executar cálculos computacionais. Estes cálculos computacionais podem ser puramente matemáticos, como o cálculo da média de um conjunto de números, ou simbólicos, como agrupar uma lista de espécies por gênero e organizá-la em ordem alfabética.

As instruções de qualquer linguagem de programação podem ser agrupadas de diferentes formas ou de acordo com a sua função:

  • Entrada. Adquire dados a partir do teclado, de um arquivo ou outro dispositivo.
  • Saída. Exibe dados ou resultados na tela, armazena-os em um arquivo ou os envia a outro dispositivo.
  • Matemática. Performa operações matemáticas como adição ou multiplicação.
  • Execução condicional. Verifica por determinadas condições e executa a sequência de instruções apropriada.
  • Repetição. Performa ação repetitiva, em geral com alguma variação.

Por mais simplista que possa parecer, qualquer programa, independente de sua complexidade, pode ser resumido por instruções de um destes cinco grupos. Desta forma, a programação consiste em dividir um problema grande e complexo em tarefas cada vez menores e simplificadas até que elas possam ser executadas por instruções básicas. E este é talvez o maior desafio para qualquer programador, compreender o problema a ser resolvido e dividi-lo em tarefas distintas.

Linguagens de programação são linguagens formais criadas por pessoas para aplicações específicas. Elas foram criadas para serem completamente, ou quase, desambigues, de modo que uma declaração tenha apenas um único sentido, independente do contexto. Elas são menos redundantes e mais concisas que as línguas naturais. A expressão “a vaca foi para o brejo”, em uma linguagem formal, a expressão será interpretada em seu significado literal. Por analogia, pode-se dizer que a poesia está para a prosa como a prosa está para a programação.

Para iniciantes na programação, é preciso acostumar-se a ler uma linguagem formal e tomar certos cuidados. Linguagens formais são mais densas, de modo que leva mais tempo para lê-las. Sua estrutura é muito importante e detalhes fazem a diferença. Pequenos erros de grafia ou pontuação podem fazer uma grande diferença e dar muita dor de cabeça.

Primeiros comandos[editar | editar código-fonte]

Python é uma linguagem interpretada que possibilita seu uso de duas formas: pelo modo interativo e pelo modo de script. Inicie o seu interpretador Python e, dependendo da versão instalada, aparecerá na tela texto semelhante a este,

 Python 2.6.5 (r265:79063, Apr 16 2010, 13:57:41)
 [GCC 4.4.3] on linux2
 Type "help", "copyright", "credits" or "license" for more information.
 >>>

A divisa >>> é a linha de comandos do interpretador e indica que ele está pronto para receber um comando. Digite 1 + 1, pressione a tecla enter e o interpretador retornará como resposta 2. Alternativamente, você também pode armazenar uma sequência de comandos em arquivos de código e utilizar o interpretador para executar o conteúdo deste arquivo, chamado de script.

Trabalhar no modo interativo é bastante conveniente para testar pequenos pedaços de código, executando-os imediatamente. Entretanto, para um número maior de linhas de comando, você deve salvar seu código em um arquivo na forma de script para executá-lo e modificá-lo no futuro.

 >>> print 'Bom dia!'
 Bom dia!

Este é o exemplo de um comando de impressão na tela. Aspas simples (') ou duplas (") indicam o início e o fim do texto a ser exibido e não aparecem no resultado. Procure acompanhar os exemplos aqui descritos experimentando-os enquanto lê o texto. Procure também experimentar novas funcionalidades e introduza erros propositalmente. Este tipo de experiência lhe ajudará a lembrar dos comandos e também a familiarizar-se com os tipos de mensagem de erros. Aprender a lidar com erros de programação é um treinamento importante, pois estes fazem parte do dia-a-dia mais do que desejamos. Além disso ao errar de propósito e conscientemente agora é preferível a cometer erros imperceptíveis depois.


Tipos de variáveis[editar | editar código-fonte]

  • Números:

Números são o primeiro tipo de variável que vem em mente e em Python temos basicamente 2 tipos de números, os inteiros (integer) e os números de ponto flutuante (float). A diferença é que as operações que utilizam exclusivamente números inteiros necessariamente retornarão números inteiros. Já as operações com, pelo menos 1 dos números float retornam float como resposta. Na pratica, temos:

Para uma dada variável a igual a 3 :

 >>> a = 3

Podemos verificar o tipo de uma variável qualquer utilizando a função type :

 >>> type(a)
 <type 'int'>

Como dito anteriormente, operações com números inteiros devem retornar valores inteiros. Então, se usarmos o operador /, que significa divisão, temos:

 >>> a/3
 1

Para definirmos um float podemos, ou colocar um ponto após o número atribuído >>> a = 3. ou multiplicarmos o número inteiro por um float neutro, como se >>> a = 3, redefinirmos >>> a = a*1.. Desta forma:

 >>> type(a)
 <type 'float'>
 >>> a/3
 1.5

  • Texto, formatando textos com (%s, %d, %i, %f):

Textos, ou strings, representam caracteres em geral, ou seja, números, letras ou outros símbolos. Strings podem ser definidas quando colocamos caracteres entre aspas (") ou apóstrofes ('). Para uma dada variável str:

 >>> str = "caract3r3s_\""
 >>> print str
 >>> "caract3r3s_""

Veja que, como apóstrofes representam os limites de uma string, para utilizar os caracteres ' ou " dentro de uma string é preciso utilizar o caractere \, ou seja, \' ou \". Como você pode prever, para utilizar o caractere \ dentro de uma string, utilizamos este caractere em par, ou seja, \\.

Existem algumas operações matemáticas que podem ser realizadas por textos. A mais simples de todas é a de soma e esta só pode ser realizada entre duas strings:

 >>> 'Python is better than '+'Matlab'
 'Python is better than Matlab'

Como viste, a soma de duas strings retorna a justaposição entre estas. A outra operação básica é a multiplicação (*). Esta só pode ser realizada entre uma string e um número inteiro (integer). Para um dado número inteiro N e um texto str1 temos que N*str1 retornará N justaposição de str1:

 >>> N = 3
 >>> 'Python is better than Matlab '*N
 'Python is better than Matlab Python is better than Matlab Python is better than Matlab '

Você pode criar uma string a partir de um número basicamente por duas formas.

Utilizando a função str():

 >>> a = str(4)
 >>> print a
 '4'

Utilizando o símbolo %:

 >>> numero = 3.145
 >>> string = '%i' %(numero)
 >>> string
 '3'
 >>> string = '%d' %(numero)
 >>> string
 '3'
 >>> string = '%s' %(numero)
 >>> string
 '3.145'
 >>> string = '%f' %(numero)
 >>> string
 '3.145'

As opções %d e %i retornam a mesma string porque significam a mesma coisa, ou seja, retornar a string referente a forma integer do número dado. A opção %s e a opção %f retornaram a mesma string, mas a primeira conta os caracteres a partir do 3, interpretando o . também como um caractere e a segunda forma conta os caracteres a partir do primeiro valor após o .. Na prática temos como determinar quantos caracteres devem ser usados utilizando um . e um número depois do símbolo %:


 >>> numero = 3.145
 >>> string = '%.3i' %(numero)
 >>> string
 '003'
 >>> string = '%.3d' %(numero)
 >>> string
 '003'
 >>> string = '%.3s' %(numero)
 >>> string
 '3.1'
 >>> string = '%.3f' %(numero)
 >>> string
 '3.145'

O mesmo pode ser feito usando a função .format() :

 >>> colocacao = 3
 >>> total = 10
 >>> print 'Na corrida, fui o {:0>3d} colocado de {:0>3d} competidores'.format(colocacao,total)
 Na corrida, fui o 003 colocado de 010 competidores

Desta forma, adiciona-se chaves {} no meio do texto com as especificações começando por :, no caso, especificamos que queremos que o número seja representado por um integer (d) de 3 caracteres alinhado no lado direito (>) e que os caracteres que sobrarem sejam substituídos por 0.

Ficou com dúvida ainda? Visite a Documentação de Python para Strings.

  • Listas

Listas são variáveis que possuem mais de uma informação, seja ela números ou textos. A forma mais simples de definir uma lista é utilizando [] colchetes. Diferente de outras linguagens, Python é uma linguagem dinâmica, então não é necessário definir o tamanho da lista antes de criá-la.

 >>> minha_lista = [2,4,1,5,'textoqualquer']

A indexação inicia do número zero. Isto significa que se queres o primeiro valor, utiliza-se [0] depois do nome da variável do tipo lista:

 >>> minha_lista[0]
 2

Em Python, cada variável é um objeto com suas propriedades. Você pode verificar a lista de propriedades de um determinado objeto usando a função dir():

 >>> dir(minha_lista)
 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', 
 '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__',
 '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
 '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index',
 'insert', 'pop', 'remove', 'reverse', 'sort']

Em geral, as propriedades que começam e terminam com "__" são informações sobre os objetos que não modificam nem calculam nada, como a __doc__ que informa o tipo de variável e como criá-la. As outras propriedades são, em geral, funções que ou retornam alguma propriedade calculada, ou modificam a lista. Você acessa uma propriedade usando o formato objeto.propriedade quando esta é uma função utiliza-se objeto.propriedade(input) em que este input pode não ser necessário. Na prática, vamos utilizar como exemplo a função append(). Podemos descobrir o que esta função faz acessando seu __doc__

 >>> minha_lista.append.__doc__
 'L.append(object) -- append object to end'

Então ela adiciona um novo objeto ao fim da lista. Para usá-la adicionaremos um novo objeto e verificaremos o que ocorre com a lista:

 >>> print minha_lista
 [2, 4, 1, 5, 'textoqualquer']
 >>> minha_lista.append('teste')
 >>> print minha_lista
 [2, 4, 1, 5, 'textoqualquer', 'teste']

Você pode usar a indexação para alterar um objeto qualquer. Assim como dito anteriormente, lembre que a indexação inicia do zero, mas saiba também que você pode contar do último para o primeiro, sendo a última posição igual a -1, a penúltima -2 e assim por diante:

 >>> print minha_lista
 [2, 4, 1, 5, 'textoqualquer', 'teste']
 >>> minha_lista[-1] = 'QualquerCoisa'
 >>> print minha_lista
 [2, 4, 1, 5, 'textoqualquer', 'QualquerCoisa']


  • Tuplos

Tuplos são muito semelhante a listas e, a primeira vista, a única diferença é que ao invés de [] colchetes utilizam () parênteses, mas a maior diferença é que os objetos dos tuplos não podem ser modificados. Estes podem ser utilizados para lista de constantes que você utilizará em seu trabalho, pois assim você se assegurará de que estas não serão modificadas:

 >>> constantes = (9.82,3.14,'textoqualquer')
 >>> type(constantes)
 <type 'tuple'>
 >>> constantes[1] = 666
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: 'tuple' object does not support item assignment


  • Dicionários

Dicionários são como um tipo especial de lista em que cada objeto tem seu próprio nome. Desta forma, a forma que se tem de indexar, ou chamar algum objeto é informando seu nome e não sua posição. Ao invés de [] colchetes, dicionários são definidos com {} chaves:

 >>> filho = {'nome':'Fulano','sobrenome':'Sicrano da Silva','idade':34,'filhos':[]}
 >>> filho2 = {'nome':'Fulaninha','sobrenome':'Sicraninha da Silva','idade':43,'filhos':[]}
 >>> pai = {'nome':'Fulanão','sobrenome':'Sicrano da Silva','idade':75,'filhos':[filho,filho2]}

Desta forma podemos mostrar que dentro de um dicionário os objetos podem ser de quaisquer tipos, como texto, no caso nos nomes, número, no caso das idades, lista, no caso dos filhos, ou até mesmo um outro dicionário.

 >>> pai['nome'] # nome do pai
 >>> 'Fulanão'

Se aparecer 'Fulan\xc3\xa3o' não se preocupe estamos usando caracteres em utf-8, mais na frente será explicado

 >>> pai['filhos'][0] # primeiro filho da lista de filhos
 {'idade': 34, 'filhos': [], 'sobrenome': 'Sicrano da Silva', 'nome': 'Fulano'}
 >>> pai['filhos'][1]['nome'] # nome do segundo filho da lista de filhos de pai
 Fulaninha


  • array

Algoritmos[editar | editar código-fonte]

De forma simples, algoritmo é uma sequência de ações que devem ser executadas para um determinado fim. Um exemplo claro de um algoritmo é uma receita de bolo: se as instruções não forem executadas na ordem necessária, não terás como resultado a finalidade desejada que é o bolo com determinada textura e sabor.

A sua relação com a programação é total, já que, programas nada mais são do que algoritmos escritos em uma determinada linguagem de programação. Como exemplo podemos utilizar o algoritmo que aprendemos no colegial para cálculo da hipotenusa de um triângulo retângulo:

 # O jogo da velha, ou sharp, representa uma linha de comentário em Python
 # Isso significa que tudo que está após o símbolo não será interpretado
 # Isto serve para que você explique o que quis fazer em uma determinada parte
 # do código ou para dar instruções para quem for ler seu programa
 
 # Vamos começar escrevendo o algoritmo em português:
 # Primeiro temos que definir os nomes e valores de cada cateto
 # Depois calculamos a soma de seus quadrados
 # E então a hipotenusa será igual a raiz quadrada desta soma
 
 # Em Python:
 cateto1 = 3
 cateto2 = 4
 
 soma = cateto1**2 + cateto2**2
 
 hipotenusa = soma**(1/2.)
 print hipotenusa

Isto deve retornar:

 5

Meu primeiro script[editar | editar código-fonte]

O exemplo a seguir calculará o produto fatorial de um número para ilustrar cada um dos cinco tipos de instruções. Enquanto você digita cada linha de código, tente identificar a qual grupo de instruções ela pertence.

 >>> # Calculo do produto fatorial n!
 ... n = input 'n = '
 >>> n = input('n = ')
 n = 3
 >>> if n == int(n):
 ...     N = 1
 ...     for i in range(n):
 ...         N *= (i + 1)
 ...     print 'n! = %d' % (N)
 ...
 n! = 6

Testando seu código[editar | editar código-fonte]

A programação é propensa a erros. Existem três tipos de erros que podem ocorrer em um programa:

  1. Erros sintáticos. Programas podem apenas ser executados se a sintaxe estiver correta. Por sintaxe entende-se a estrutura de um programa e as regras que regem tal estrutura. Tomando como exemplo n = 1 / (2 * (3 + 4), ocorrerá um erro de sintaxe devido à ausência de um parenteses fechando a expressão.
  2. Erros de execução. São erros que surgem apenas durante a execução do programa. Eles também são chamados de exceções e indicam a ocorrência de algo excepcionalmente ruim.
  3. Erros semânticos. Estes estão dentre os erros mais difíceis de serem detectados. Eles ocorrem quando o código possui um erro de lógica de programação e acaba não gerando nenhuma mensagem de erro, tanto de sintaxe quanto de exceção. Por exemplo, se quisermos descobrir o quanto é duas vezes o valor da soma 3 + 4 e escrevermos a expressão a = 2 * 3 + 4, o resultado não será \lstinline{14}. Neste caso temos um erro no significado do programa (na semântica) e o interpretador não identificará este erro pois o problema foi mau formulado.

Remover erros em programas, ou depurar, é uma das habilidades mais importantes na programação. É, ao mesmo tempo, um trabalho de detetive e de cientista experimental. Principalmente quando há erros erros semânticos, procura-se pela causa desconhecida através de testes de hipótese.

Para minimizar os erros durante a programação, Beck (2003) sugere a adoção de uma técnica de desenvolvimento regida por testes (TDD — test-driven development). TDD parte do princípio de que antes de se solucionar cada uma das pequenas partes que compõem um programa, deve-se formular testes específicos e apenas avançar para o próximo estágio quando todos os testes anteriores passarem.

Exercícios[editar | editar código-fonte]

Exercício 1. Inicialize o interpretador do Python e digite help() para abrir o utilitário de ajuda. Se este comando não funcionar, você deve procurar instalar a documentação adicional do Python ou configurar uma variável de ambiente local, dependendo de seu sistema operacional. Outra forma de exibir a documentação de um comando específico, como por exemplo o comando print, é digitar help(print).

Exercício 2. Utilize um navegador Internet para acessar a página python.org. Esta página possui informações sobre a linguagem Python, atalhos para páginas relacionadas a Python e também possibilita a busca em sua documentação. Faça uma busca e discuta o resultado do comando

 >>> print '%d * %s = %.2f' % (2, 'pi', 2 * 3.1415926535897931)
 2 * pi = 6.28

Exercício 2. Utilize o interpretador do Python como uma calculadora. Seja dado o seguinte conjunto de valores: [1, 10, 8, 6, 5, 3, 2, 5, 5, 3]. Determine a soma, os valores mínimo e máximo e a média da série. Lembre que os operadores matemáticos no Python possuem notação semelhante à que estamos acostumados nas aulas de matemática, ou seja, +, -, * e / denotam respectivamente adição, subtração, multiplicação e divisão.

Referências

Beck, Kent. Thest-driven development: By example. Addison-Wesley, 2003. 220 p.

Downey, Allen. Think Python: How to think like a computer scientist. Green Tea Press, 2008. 214 p.

Primeiros passos

Bibliotecas[editar | editar código-fonte]

Este guia é baseado em Python versão 2.7 e utiliza bibliotecas promovidas pela NumPy Foundation for Open Code for Usable Science (NumFOCUS)[3]. A NumFOCUS tem por missão patrocinar o desenvolvimento de linguagens the alto nível para ciência; promover estudos com orientação a matrizes e abordagens computacionais de altas ordens e ciência computacional aplicada; promover o uso de código aberto e incentivar a pesquisa reprodutível. Dentre os seus principais projetos, destacam-se

  • NumPy. Pacote fundamental para computação científica com Python. Numpy adiciona uma ferramenta rápida e sofisticada para manipulação de matrizes à linguagem Python. Ela é requisito para as duas bibliotecas citadas acima e é instalada automaticamenteo ao instalar-se qualquer uma delas.
  • SciPy. Ferramentas científicas para Python (Scientific tools for Python) é uma biblioteca que possui manipulação de matrizes n-dimensionais rápida e conveniente. Ela fornece uma série de rotinas numéricas amigáveis para integração, otimização numérica e análise estatística avançada.
  • matplotlib. Biblioteca para criação de gráficos e figuras de alta qualidade em uma variedade de formatos. Também possui ferramentas para a criação de mapas através do complemento “basemap”.
  • pandas. Biblioteca para estrutura de dados e ferramentes de análise de dados. É de uso fácil e de alta performance.
  • scikits-learn. Módulo destinado a resolver problemas de aprendizagem de máquina (machine learning) de forma acessível.
  • scikits-image. Coleção voluntária de algoritmos de alta qualidade e revisada por pares para processamento de imagens.

Para aplicações oceanográficas, também existem as seguintes bibliotecas que extendem as funcionalidades:

  • seawater. O pacote fornece funções básicas para determinar propriedades físicas da água do mar como densidade, calor armazenado, etc.
  • PyDAP Biblioteca que implanta o protocolo de acesso a dados DAP, também conhecido por DODS ou OPeNDAP.

Algumas operações[editar | editar código-fonte]

Funções lambda[editar | editar código-fonte]

 lon180 = lambda x: x + (x <= -180) * 360 - (x > 180) * 360

Estatísticas simples[editar | editar código-fonte]

  • Média
  • Desvio padrão
  • Mínimo
  • Máximo
  • Mediana

Primeiro gráfico[editar | editar código-fonte]

 # -*- coding: iso-8859-1 -*-
 import pylab
 
 v0 = -10. # Velocidade inicial (m/s)
 a = 2.5   # Aceleracao (m**2/s)
 
 t = pylab.arange(0., 10.1, 0.1)
 v = v0 + v0 * t + 0.5 * a * t ** 2
 
 pylab.plot(t, v)
 pylab.title(u'Movimento uniformimente variavel')
 pylab.xlabel('Tempo (s)')
 pylab.ylabel('Velocidade (m/s)')
 pylab.show()

Guia de estilo[editar | editar código-fonte]

Um aspecto importante na hora de se escrever código em qualquer linguagem é a legibilidade, principalmente levando-se em conta que código é lido com maior frequência que escrito. Por isso Guido van Rossum e Barry Warsaw sugerem um guia estilo para a formatação de código na linguagem Python. A íntegra em inglês deste guia pode ser consultada no atalho ao lado Guia de estilo para código Python. Ele foi elaborado para garantir consistência no código escrito. Atenção na formatação do código e na sua documentação é importante para consultas futuras, principalmente para justificar determinadas soluções adotadas quando não podemos contar com nossa memória. Um resumo do guia de estilo citado é apresentado a seguir.

Leiaute[editar | editar código-fonte]

Identação[editar | editar código-fonte]

Cada nível de identação deve ser composto por quatro (4) espaços. O uso de tabulações não é recomendado e não se deve misturar tabulações com espaços. Os principais editores disponíveis possuem recursos para a utilização de espaços ao invés da tabulação.

Extensão das linhas[editar | editar código-fonte]

As linhas de código não devem possuir mais de 79 caracteres. Muitos dispositivos de exibição são limitados a 80 caracteres cuja quebra de texto pode distorcer a estrutura visual do código, dificultando a sua compreensão. Para blocos de texto longos (documentação ou comentários), recomenda-se o limite de 72 caracteres por linha. Seguindo estas recomendações pode-se, em dispositivos de maior resolução, utilizar múltiplas janelas de código lado a lado para consulta simultânea.

Continuação de linha implícita do Python pode ser feita entre parênteses (( )), colchetes ([ ]) ou chaves ({ }). Linhas compridas podem ser divididas envolvendo-se expressões entre parênteses, mantendo a identação apropriada. A região preferida para quebra de operadores binários é após o operador ao invés de antes dele. O código a seguir ilustra um exemplo de quebra de linhas.

# -*- coding: iso-8859-1 -*-
class Rectangle(Blob):
    def __init__(self, width, height,
                 color='black', emphasis=None, highlight=0):
        if (width == 0 and height == 0 and
            color == 'red' and emphasis == 'strong' or
            highlight > 100):
            raise ValueError("sorry, you lose")
        if width == 0 and height == 0 and (color == 'red' or
                                           emphasis is None):
            raise ValueError("I don't think so -- values are %s, %s" %
                             (width, height))
        Blob.__init__(self, width, height,
                      color, emphasis, highlight)

Linhas em branco[editar | editar código-fonte]

Separe as definições de funções e de classes de nível superior com duas linhas em branco. Definições de métodos dentro de uma classe são separadas por uma única linha. Linhas em branco extras podem ser utilizadas moderadamente para separar grupos de funções relacionadas. Nas funções utilize linhas em branco para indicar seções lógicas.

Codificação de caracteres[editar | editar código-fonte]

Todo o código Python deve utilizar a codificação de caracteres ASCII ou Latin-1 (ISO-8859-1). Para Python 3.0 ou superior a codificação preferida é UTF-8.

Importações[editar | editar código-fonte]

Comandos de importação devem estar em linhas separadas, como por exemplo em

 import os
 import sys
 import numpy
Yes check.svg

Deve-se evitar

  import os, sys, pylab
X mark.svg

No entanto, para a importação de funções de uma mesma biblioteca pode-se utilizar

from numpy import array, cos, pi
Yes check.svg

As importações devem ser listadas no topo do arquivo, logo abaixo da documentação e dos comentários do módulo. Elas devem ser agrupadas seguindo a seguinte ordem:

  1. Módulos da biblioteca padrão;
  2. Módulos de terceiros relacionados;
  3. Módulos locais e/ou específicos para a aplicação.

Deve-se separar grupos de importação por uma linha em branco. Qualquer especificação __all__ deve ser feita após as importações.

Espaços em branco[editar | editar código-fonte]

Em expressões ou declarações, evite espaços em branco estranhos nas seguintes situações:

  • Imediatamente dentro de parênteses, colchetes ou chaves;
fruta(maca[1], {pera: 2})
Yes check.svg
fruta( maca[ 1 ], { pera: 2 } )
X mark.svg
  • Imediatamente antes de uma vírgula, ponto-e-vírgula e dois-pontos;
if x == 4: print x, y; x, y = y, x
Yes check.svg
if x == 4 : print x , y ; x , y = y , x
X mark.svg
  • Imediatamente antes de parênteses que inicia a lista de argumentos de uma chamada de função;
fruta(1)
Yes check.svg
fruta (1)
X mark.svg
  • Imediatamente antes de parênteses de abertura que inicia uma indexação ou corte;
dict['chave'] = list[indice]
Yes check.svg
dict ['chave'] = list [indice]
X mark.svg
  • Mais de um espaço ao redor de um operador de atribuição para alinhamento.
x = 1
y = 2
var_longa = 3
Yes check.svg
x         = 1
y         = 2
var_longa = 3
X mark.svg

Outras recomendações:

  • Sempre cerque os seguintes operadores binários com um espaço simples de cada lado: atribuição =, atribuição de incremento +=, -=, ...), comparações (==, <, >, !=, <>, <=, >=, in, not in, is, is not), booleanos (and, or, not);
  • Utilize espaços ao redor de operadores aritméticos;
i = i + 1
enviado += 1
x = x * 2 - 1
hipot2 = x * x + y * y
c = (a + b) * (a - b)
Yes check.svg
i=i+1
enviado +=1
x = x*2 - 1
hipot2 = x*x + y*y
c = (a+b) * (a-b)
X mark.svg
  • Não utilize espaços ao redor do sinal de = quando indicar um argumento de palavra-chave ou um valor de parâmetro padrão;
def complexo(real, imag=0.0):
    return magico(r=real, i=imag)
Yes check.svg
def complexo(real, imag = 0.0):
    return magico(r = real, i = imag)
X mark.svg
  • O uso de instruções compostas~(múltiplas instruções na mesma linha) não é recomendado;
if oque == 'blah':
    fazer_blah()
fazer_um()
fazer_dois()
fazer_tres()
Yes check.svg
if oque == 'blah': fazer_blah()
    fazer_um(); fazer_dois(); fazer_tres()
X mark.svg

Comentários[editar | editar código-fonte]

Comentários são utilizados para inserir anotações no módulo que sejam legíveis a qualquer programador. Eles são incluídos para facilitar a compreensão do código. Um bom comentário não pode contradizer o código escrito. Tenha cuidado em manter os comentários atualizados quando houver mudança no código. Eles devem ser sentenças completas respeitando as normas gramaticais e terminando com um ponto final. Para código de uso pessoal ou restrito, os comentários podem ser em qualquer idioma. Para códigos mais abrangentes, recomenda-se redigir os comentários em inglês.

Em bloco. Comentários em bloco geralmente aplicam-se a todo ou parte do código que se segue. Eles devem ser identados no mesmo nível deste código. Cada linha de um comentário em bloco inicia com um caractere # e um espaço simples. Parágrafos dentro do bloco são separados por uma linha contendo apenas um # devidamente identado.

Em linha. Utilize comentários em linha com moderação. Este comentário deve estar na mesma linha da declaração, separado de ao menos dois espaços. Ele inicia com um caractere \lstinline{#} e um espaço simples. Comentários em linha podem ser desnecessários e até distrair quando afirmam o óbvio. Veja os exemplos abaixo:

x = x + 1     # Compensa borda
Yes check.svg
x = x + 1     # Incrementa x
X mark.svg

Documentação[editar | editar código-fonte]

Escreva a documentação (docstrings) para todos os módulos, funções, classes e métodos públicos. Ele é a sequência literal que segue a declaração de um módulo, função, classe ou método. Esta sequência torna-se o atributo especial __doc__ deste objeto. Documentação não é necessária para métodos não-públicos, entretanto deve haver uma descrição sobre a funcionalidade do método. A sequência deve estar entre """(...)""" como ilustrado a seguir:

def complexo(real=0.0, imag=0.0):
    """Forma um numero complexo.
    
    Argumentos:
        real -- a parte real (padrao 0.0)
        imag -- a parte imaginaria (padrao 0.0)
    
    """
    ...

Note que o trio de aspas """ que fecha a documentação está em uma linha por sí só e é preferencialmente precedida por uma linha em branco. Para o caso de texto descritivo de uma linha apenas, as aspas de fechamento podem estar na mesma linha.

Versões[editar | editar código-fonte]

Manter registro e controle de revisões e versões é importante para certificar-se de que se está trabalhando com a versão mais atualizada. As seguintes linhas devem ser incluidas após a sequência de documentação do módulo e antes de qualquer outro código, separado por uma linha em branco acima e abaixo. Além de manter o controle de versões de cada módulo, sistemas de controle de revisão como Subversion, Github ou CVS podem propagar atualizações automaticamente.

__version__ = "$Revision: 1234 $"
# $Source$

Convenções de nomenclatura[editar | editar código-fonte]

Há diversos estilos de nomenclatura e é importante ser capaz de reconhecer cada um deles, independentemente de seu uso. Distingue-se comumente os seguintes estilos:

  • b -- letra minúscula simples;
  • B -- letra maiúscula simples;
  • minúsculas;
  • minúsculas_com_traço_baixo;
  • MAIÚSCULAS;
  • MAIÚSCULAS_COM_TRAÇO_BAIXO;
  • IniciaisMaiúsculas ou CamelCase. Note que, neste caso, as abreviações devem ser utilizadas na forma maúscula (ex.: HTTPServerError);
  • caixaMista;
  • Palavras_Capitalizadas_Com_Traço_Baixo.

As seguintes formas especias que utilizam o traço baixo como prefixo ou sufixo também são reconhecidas:

  • _traço_baixo_inicial — indicador de uso interno. Por exemplo, from M import * não importa os objetos cujo nome inicia com um traço baixo;
  • traço_baixo_final_ — utilizado por convenção para evitar conflitos com palavras-chave do Python~(ex.: Tkinter.Toplevel(master,class_='ClassName');
  • __traço_baixo_inicial_duplo — ao nomear um atributo de classe, invoca a deformação de seu nome;
  • __traço_baixo_inicial_e_final_duplos__ — objetos `mágicos' que existem em espaços de nome controlados pelo usuário (ex.: __init__, __import__ ou __file__). Nunca invente estes nomes, utilize apenas como documentado.


Exercícios[editar | editar código-fonte]

Exercício 1. Descreva um algoritmo para (...)

Referências

Juntando os pedaços

Operadores lógicos e condicionais[editar | editar código-fonte]

Iterações[editar | editar código-fonte]

Manipulação de dados[editar | editar código-fonte]

Salvando e carregando[editar | editar código-fonte]

Arquivos MATLAB®[editar | editar código-fonte]

Visualização[editar | editar código-fonte]

Exercícios[editar | editar código-fonte]

Exercício 1. Carregue os dados da série temporal do Bermuda Atlantic Time-series Study (BATS) e plote um diagrama de temperatura e salinidade (T-S).

Avançando

Tratamento de dados[editar | editar código-fonte]

Média móvel[editar | editar código-fonte]

Tendência e ajuste de funções[editar | editar código-fonte]

Interpolação[editar | editar código-fonte]

Visualização elaborada[editar | editar código-fonte]

Perfis[editar | editar código-fonte]

Contornos[editar | editar código-fonte]

Histogramas[editar | editar código-fonte]

Exercícios[editar | editar código-fonte]

Exercício 1. Sobreponha ao diagrama T-S do capítulo anterior a feição média de T-S com linha contínua vermelha e 2 pixels de espessura. Transforme este diagrama T-S em um diagrama de estado ao incluir as isolinhas de densidade no fundo através do comando contour.

Exercício 2. Visite a página Internet da biblioteca Matplotlib e pesquise pelo comando subplot. Gere uma figura com dois gráficos lado a lado, o da esquerda contendo o diagrama de estado do exercício anterior e o da direita contendo os perfis médios de temperatura e salinidade desde a superfície até 2500 m de profundidade.

Fluência

Análise espectral[editar | editar código-fonte]

Mapas[editar | editar código-fonte]

pyDAP[editar | editar código-fonte]

Exercícios[editar | editar código-fonte]

Colinha

Wikibooks-logo-pt.svg Este livro ou módulo precisa ser formatado segundo o modelo wiki e/ou organizado conforme as convenções do Wikilivros. (discuta)
Por favor ajude a formatar este módulo de acordo com as diretrizes estabelecidas no livro de estilo.
Editor: considere colocar o mês e o ano da marcação.

BREVE GUIA DE PYTHON ESCRITO POR AMADOR

Observação importante: Neste guia podem (!) conter informações erradas.

INTRODUÇÃO[editar | editar código-fonte]

Tipos de variáveis:

- int: 5                  }
- float: 5.0		   } --> Usar a função type(variavel).
- str: '5.0' ou "5.0"     }
- complex: 5 + 0j	   }

Objetos importantes:

- lista: l = [1, 2, 3]
- tuple: t = (1, 2, 3) ou (1,)
- dicionário: d = {'a': [1, 2, 3], 'b': [4, 5, 6]}

Observações dos objetos:

- "Lists are mutable, strings and tuples are immutable."
- "a == b" retorna True se eles têm o mesmo valor.
- "a is b" retorna True se eles são a mesma coisa (ocupam o mesmo espaço na memória).
- d['a'] retorna [1, 2, 3]
- d['b'][1] retorna 5
- d.keys() retorna ['a', 'b']
- d.values() retorna [[1, 2, 3], [4, 5, 6]]

Uso do help: help(<comando>) Ajuda também: <comando>? Para ver o código de uma função: <comando>??

  1. --> Comentário.

ESPECIFICAÇÕES INICIAIS E IMPORTAÇÃO DE BIBLIOTECAS[editar | editar código-fonte]

"# -*- coding: utf-8 -*-" --> (Sem aspas, na primeira linha do algoritmo) possibilita a utilização de acentos gráficos no algoritmo. from __future__ import division # Razão entre inteiros se torna real. from pylab import * # Não é recomendável importar tudo da biblioteca; escrevi para lembrar! import numpy as np # Numerical Python. from matplotlib import pyplot as plt # Matplotlib.

u'string' --> Leitura do string como unicode. r'string' --> Leitura do string como raw. Obs: Dá pra usar os comandos do Latex na escrita de textos!

& --> E. | --> Ou. = --> Atribuição. == --> Comparação de igualdade. != --> Comparação de diferença.

  1. LIMPEZA DA CASA:
  2. del a, b, c # Descomentar para apagar possíveis variáveis.

plt.close('all') # Fechamento das figuras abertas. clear # Limpeza da linha de comando.

COMANDOS GERAIS[editar | editar código-fonte]

run script.py --> Roda o algoritmo no Terminal. paste --> Idem a Ctrl+V. who --> Lista de variáveis. whos --> Lista de variáveis com descrição.

print('Texto') --> Escreve o texto na linha de comando. str(3) --> Idem ao num2str do Matlab. str1 + str2 --> Concatenação de strings. 'exemplo %d de string' % 4 --> Isso tudo é o string: 'exemplo 4 de string'; usar o formato "string % variável". %6.2f --> 2 algarismos depois da vírgula (já arredondado) e ocupando 6 caracteres ao todo. \n --> Mudar de linha. Obs: Dá pra usar os comandos do Latex na escrita de textos!

a[-1] --> Refere-se ao último elemento de a. b = a[:] --> b vira uma cópia de a ("a == b" retorna True e "a is b" retorna False). "a = 3; b = 4;" --> Pode ir na mesma linha. Dá pra fazer por tuple também.

range(a) --> Lista de 0 até (a-1) de 1 em 1. range(a, b) --> Lista de a até (b-1) de 1 em 1. range(a, b, n) --> Lista de a até b de n em n (exclusive b). np.arange(a, b, n) --> Matriz de a até b de n em n (exclusive b). np.linspace(a, b, n) --> Matriz de a até b com n elementos (b incluso). np.array([1, 2, 3]) --> Matriz unidimensional. np.array([[1, 2],[3, 4]]) --> Matriz bidimensional.

m.sum() == np.sum(m) --> Quando 'm' é matriz. m.shape --> Retorna um tuple com as dimensões da matriz. m.size --> Retorna o número de elementos de uma matriz.

if, elif e else --> Começar com if; usar quantos elif quiser; else é opcional.

for <variável> in <lista>: --> Loop. Não há um "end". Uso da identação!

np.savez('vars', x, y, z) dat = np.load('vars.npz') a = dat['arr_0'] b = dat['arr_1'] c = dat['arr_2'] (a, b, c) = (dat['arr_0'], dat['arr_1'], dat['arr_2']) x, y, z podem ser números, matrizes, listas ou strings; o np.load sempre retornará matrizes (a, b, c serão matrizes). Deve ter um jeito mais inteligente de se fazer isso. Obs: Não sei se é com esse mesmo procedimento, mas é possível ler arquivos .mat.

p = np.loadtxt(<string do caminho do arquivo>, skiprows = 20, usecols = (2,)) --> Leitura de arquivo ASCII.

plt.show() --> Mostra figura em questão. plt.close() --> Fecha a figura em questão. fig = gcf() --> Faz um handle da figura em questão. ax = gca() --> Faz um handle do eixo em questão.

EXEMPLO DE CONFECÇÃO DE FUNÇÃO[editar | editar código-fonte]

def pitagoras(a, b): c = np.sqrt(a**2 + b**2) return c

Obs: A ser colocada no início dos algoritmos.

EXEMPLO DE UM PLOT SIMPLES BEM FEITO[editar | editar código-fonte]

fig, ax = plt.subplots(figsize=(7, 5)) ax.plot(x, y, '--b', label='Seno', linewidth=2) # Label é a legenda. ax.plot(2, 1, 'or', label='Cosseno', markersize=12) # Label é a legenda. legend(loc='upper left')

xlim(-5, 5) xticks([-np.pi, 0, np.pi], [r'$-\pi$', r'$0$', r'$\pi$']) ylim(-10, 10) yticks(linspace(-1, 1, 3), [r'$-1$', r'$0$', r'$1$'])

ax.set_title('Título') ax.set_ylabel('Imagem') ax.set_xlabel('Dominio') fig.savefig('name.png', transparent=True)


5.1 Mudança na posição dos eixos (origem):

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


5.2 Alternativa para definição do tamanho da figura: usar o comando fig.get_size_inches.

5.3 Inversão de eixos (para plotagens de perfis!): ax.invert_yaxis()

5.4 Plotando circulos: plt.scatter(x, y, <tamanho>, 'k', edgecolor = 'none', alpha = 0.5)

EXEMPLOS DE COMANDOS ESPECÍFICOS[editar | editar código-fonte]

6.1 Trabalhando com tempo:

from datetime import datetime, timedelta

d1 = datetime(1991, 7, 30) d2 = datetime(1995, 2, 15) dt = d2 - d1 --> dt será datetime.timedelta(1296)

dt = timedelta(days = 2, hours = 3)


6.2 Trabalhando com mapas:

Google: "matplotlib basemap" from mpl_toolkits.basemap import Basemap help(Basemap) --> Há um exemplo! map = Basemap([...]) --> Lembrar que map é um objeto e que "map."+TAB é útil.

BIBLIOTECAS[editar | editar código-fonte]

Padrão: from __future__ import division # Razão entre inteiros se torna real. import numpy as np # Numerical Python. from matplotlib import pyplot as plt # Matplotlib.

Módulos da "Standard library" do Python: import os # Operation System. from glob import glob # "Globbing" de arquivos.

Manipulação de netCDF (local/remoto): from netCDF4 import Dataset

Mapas: from mpl_toolkits.basemap import Basemap, shiftgrid, cm

OBS: Não usar a seawater, ela está obsoleta! Usar a gsw (GibbsSeaWater).

INSTALAÇÃO[editar | editar código-fonte]

O Python já vem com o Ubuntu. Baixar (via Ubuntu Software Center): Ipython, Matplotlib, Numpy, Scipy, Basemap.

A biblioteca básica para oceanografia é a gsw (GibbsSeaWater).

Opcional: atualizar o .bashrc com o exemplo abaixo:

  1. Ipython alias:

alias py='ipython'


8.1 Baixar pacotes (roteiro usado somente para o EPD?):

1. Criar a pasta "modules" na pasta do Python. 2. Escrever no .bashrc: "export PYTHONPATH=$PYTHONPATH$HOME/softwares/python/modules". 3. Google: python seawater (por exemplo). 4. No site certo, clicar em "Source" e copiar o "command line access" para o Terminal. 5. (Precisa ter o Mercurial instalado.) 6. Fazer um link simbólico com: "$ ln -s /home/usuario/softwares/python/modules/python-seawater/seawater /home/usuario/python/modules/seawater". 7. Conferir se o link simbólico foi feito.

EXEMPLO DE COMEÇO DE ALGORITMO[editar | editar código-fonte]


  1. -*- coding: utf-8 -*-
    1. PLOTAGEM DE PERFIL DE OXIGÊNIO DISSOLVIDO
    2. Autor: [...]
    3. Data: 22/jan/2013
    4. E-mail: [...]


  1. IMPORTAÇÃO DE BIBLIOTECAS:

from __future__ import division # Razão entre inteiros se torna real. import numpy as np # Numerical Python. from matplotlib import pyplot as plt # Matplotlib.


  1. LIMPEZA DA CASA:
  1. del a, b, c # Descomentar para apagar possíveis variáveis.

plt.close('all') # Fechamento das figuras abertas. clear # Limpeza da linha de comando.

Exemplos

Exemplos de programas para Oceanografia em python:

Plot de perfis[editar | editar código-fonte]

Neste exemplo, vamos plotar um perfil de temperatura do oceano:

A primeira linha do código que iremos escrever é a importação da biblioteca pylab. Com ela, será possível fazer com que o Python desenhe o perfil:

 
import pylab # importando a biblioteca PyLab
  

Feito isso, vamos então montar os vetores de dados de temperatura e suas respectivas profundidades. Aqui, vamos utilizar dados obtidos do WOA09 (grade de 5°), na latitude -27,5 e longitude -37,5. Para mais informações sobre o WOA09, clique aqui:

 
temp = [23.4859, 23.4130, 23.2890, 23.1366, 22.4640, 21.1481, 20.1275, 19.2069, 18.2899, 16.6416, 15.4535, 14.5209, 12.7510, 10.6054, \
8.3869, 6.4448, 5.0789, 4.2432, 3.7263, 3.3810, 3.1703, 3.0694, 3.0519, 3.0522, 3.1440, 3.1527, 3.0166, 2.7636, 2.2191, 1.1146, 0.2896];  # Vetor temperatura

prof = [0, 10, 20, 30, 50, 75, 100, 125, 150, 200, 250, 300, 400, 500, 600, 700, 800, 900, 1000, 1100,\
1200, 1300, 1400, 1500, 1750, 2000, 2500, 3000, 3500, 4000, 4500]; # Vetor profundidade
  

O uso da \ na construção dos vetores é só para quebrar a linha do comando para fins de visualização do código.

Bom, agora vamos plotar os dados. Para isso, vamos utilizar o comando plot e show da biblioteca pylab:

 
pylab.plot(temp, prof, label='Temp')
pylab.show()
  

Isso vai fazer com que seja desenhado uma linha em azul ligando os pares temperatura X profundidade. O resultado será esse:

Perf 1 etapa

Como dá para perceber, o perfil já está desenhado, porém ainda mal apresentado (i.e. sem título, labels, unidades das variáveis, orientação dos eixos etc). Para melhorar a aparência do gráfico vamos adicionar alguns comandos:

 
import pylab

temp = [23.4859, 23.4130, 23.2890, 23.1366, 22.4640, 21.1481, 20.1275, 19.2069, 18.2899, 16.6416, 15.4535, 14.5209, 12.7510, 10.6054, \
8.3869, 6.4448, 5.0789, 4.2432, 3.7263, 3.3810, 3.1703, 3.0694, 3.0519, 3.0522, 3.1440, 3.1527, 3.0166, 2.7636, 2.2191, 1.1146, 0.2896];  # Vetor temperatura

prof = [0, 10, 20, 30, 50, 75, 100, 125, 150, 200, 250, 300, 400, 500, 600, 700, 800, 900, 1000, 1100,\
1200, 1300, 1400, 1500, 1750, 2000, 2500, 3000, 3500, 4000, 4500]; # Vetor profundidade

pylab.plot(temp, prof, label='Temp')

xmin=min(temp); # acha o valor mínimo da temperatura
xmax=max(temp); # acha o valor máximo da temperatura
pylab.xlim(xmin-((xmax-xmin)*0.05), xmax+((xmax-xmin)*0.05)); """ informa os intervalos de temperatura a serem apresentados no plot. So para deixar um
espaço, evitando que a linha do perfil fique colada aas bordas do grafico """

ymin=min(prof); # acha o valor mínimo da profundidade
ymax=max(prof); # acha o valor máximo da profundidade
pylab.ylim(0, ymax+((ymax-ymin)*0.1)); # alterando os intervalos da profundidade. O valor zero costuma ser o inicio. Sem espaco na parte superior do perfil.
 
pylab.xlabel('Temperatura ($^\circ$C)') # label do eixo X
pylab.ylabel('Profundidade (m)') # label do eixo Y
pylab.title('Perfil de Temperatura') # titulo do grafico
pylab.grid(True) # colocando uma grade
pylab.gca().invert_yaxis() # invertendo a orientacao do eixo Y, assim, o topo será o menor valor (''i.e.'' zero) e a base será o maior valor de profundidade.
pylab.legend(loc=4) # inserindo uma legenda para o perfil. A opcao loc=4 intrui o Python a colocar a legenda no canto inferior direito.

pylab.show()
  

O resultado final será o seguinte:

Perf final

Diagrama TS[editar | editar código-fonte]

O Diagram TS é uma importante ferramenta gráfica para os oceanógrafos. Neste exemplo, vamos construir um diagrama TS com valores obtidos do WOA09, no mesmo ponto de grade do exemplo Plot de perfis.

Além da biblioteca pylab, vamos também importar o pacote de rotinas Gibbs Sea Water. Para instalação e mais informações sobre essa toolbox, clique aqui. Se quiser saber mais sobre a Thermodynamic Equation Of Seawater - 2010 (TEOS-10), clique aqui:

 
import pylab # importando a biblioteca PyLab
from seawater.gibbs import * # importando a biblioteca Gibbs Sea Water
  

Vamos agora fornecer os dados de temperatura e salinidade para a construção do diagrama:

 
temp = [23.4859, 23.4130, 23.2890, 23.1366, 22.4640, 21.1481, 20.1275, 19.2069, 18.2899, 16.6416, 15.4535, 14.5209, 12.7510, 10.6054, \
8.3869, 6.4448, 5.0789, 4.2432, 3.7263, 3.3810, 3.1703, 3.0694, 3.0519, 3.0522, 3.1440, 3.1527, 3.0166, 2.7636, 2.2191, 1.1146, 0.2896]

sal = [36.3923, 36.3707, 36.3762, 36.3995, 36.4141, 36.3823, 36.2633, 36.1235, 35.9743, 35.7269, 35.5702, 35.4497, 35.1857, 34.8950, \
34.6285, 34.4319, 34.3314, 34.3130, 34.3387, 34.3865, 34.4492, 34.5187, 34.5901, 34.6574, 34.7908, 34.8745, 34.9254, 34.9204, 34.8727, 34.7555, 34.6795]
  

Agora uma parte que vai caracterizar o diagrama TS: o plot das isopicnais:

 
sal_vet = linspace(32,38,100) # vetor salinidade
temp_vet = linspace(-2,32,100) # vetor temperatura
[S,T] = meshgrid(sal_vet,temp_vet) # criando a malha do campo temperatura e salinidade
DENS = rho(S,T,0) # obtendo a densidade a partir dos valores de temperatura e salinidade, considerando a profundidade=0 m.
  

O que foi feito aqui é a criação dos campos de temperatura, salinidade e calculando o campo de densidade a partir das equações da TEOS-10. Com isso, é possível criar um gráfico com as isolinhas de densidade. Isso ficará como o fundo do diagrama. Além disso, vamos plotar por cima destas isopicnais os pares TS representados por círculo azuis:

 
CS = pylab.contour(S,T,DENS,20,colors='0.5') # contornado o gráfico com isolinhas de densidade
pylab.clabel(CS, inline=1, fontsize=10) # inserindo os valores de densidade nas linhas contornadas
pylab.plot(sal, temp,'o', label='TxS') # plotando os pares TS
  

Para finalizar, vamos "arrumar" o diagrama para que ele fique um pouco mais apresentável e plotá-lo:

 
xmin=min(sal);
xmax=max(sal);

pylab.xlim(xmin-((xmax-xmin)*0.15), xmax+((xmax-xmin)*0.15));

ymin=min(temp);
ymax=max(temp);

pylab.ylim(ymin-((ymax-ymin)*0.15), ymax+((ymax-ymin)*0.15));
 
pylab.xlabel('Salinidade')
pylab.ylabel('Temperatura ($^\circ$C)')
pylab.title('Diagrama TS')

pylab.show()
  

O resultado final será o seguinte:

Perf dens 1

Dúvidas frequentes

Como alterar a formatação das linhas de grade em um gráfico?[editar | editar código-fonte]

O comando grid do módulo matplotlib.pyplot possui uma série de parâmetros disponíveis para a formatação da grade de um gráfico. Para maiores informações, consulte por help(plt.grid). O exemplo a seguir plota uma grade com linhas tracejadas brancas a cada divisão maior em ambos os eixos.

 plt.grid(which='major', axis='both', color='w', linestyle='--')