SciPy
PyCUDA
Prof. Marco André Argenta
Grupo de bioengenharia ­ CESEC/UFPR

Neste curso de introdução à
linguagem de programação Python,
pretende-se
trabalhar
com
os
componentes básicos e fundamentais da
linguagem, fazendo com que o aluno
tenha plena capacitação de iniciar o
desenvolvimento em python.
Além do básico e do
fundamental da linguagem, serão
discutidos alguns aspectos como o
ambiente de programação, os pacotes
mais úteis para a programação científica,
visualização, geração de ambiente, etc.
Por fim, uma introdução ao PyCUDA,
wrapper para programação em placas
de video da nvidia usando o python e o
CUDA.

2

Módulo I
1. Um pouco de história
2. Introdução
3. Configurando o Eclipse
4. Introdução à Sintaxe
5. Construções Básicas
6. Tipos Básicos
7. Biblioteca Padrão
8. Referências

3

Nascimento do python, bases do python e o ambiente de
concepção, quem usa?

4







Criada em 1989 pelo holandês Guido van Rossum no Centrum voor
Wiskunde en Informatica (CWI), em Amsterdã, Holanda.
Influenciada pela linguagem ABC, desenvolvida no CWI por Guido e
outros nas décadas de 70 e 80. ABC tinha um foco bem definido: ser uma
linguagem de programação para usuários inteligentes de computadores
que não eram programadores: Físicos, engenheiros, cientistas sociais e até
linguistas.
O projeto de sistema operacional distribuído Amoeba precisava de uma
linguagem de script. Nasce o Python.

5










Elementos que eram bem sucedidos no ABC.
Estruturas de dados poderosas inclusas: Listas, Dicionários, Strings.
Usar indentação para delimitar blocos, eliminando chaves.
Fácil extensão (lição aprendida com os erros do ABC).
Fácil de portar: além do Amoeba, gostaria de executar em Unix,
Macintosh e Windows.
Influências de Modula-2 e Modula-3: módulos e namespaces.

6





Universidade: pessoas altamente especializadas para desenvolver e
opinar sobre os elementos do projeto;
Descontraído: o nome Python vem da série de humor Monty Python's
Flying Circus;








Monty Python's Flying Circus (em Portugal também conhecido, mas
raramente, por Os Malucos do Circo) foi um série para televisão
britânica transmitido pela BBC entre 1969 a 1974. Consistiu de 45
episódios divididos em 4 temporadas.
A série, que foi ao ar pela primeira vez em 5 de outubro de 1969,
foi criada, roterizada e estrelada pelos Monty Python Graham
Chapman, John Cleese, Terry Gilliam, Eric Idle, Terry Jones e Michael
Palin.

Sem prazos, Sem pressão: o desenvolvimento não foi
pressionado por estratégias de marketing, prazos,
clientes ou qualquer outro fator que pudesse
influenciar nas decisões de projeto, resultando em
maior qualidade;
Software Livre: garante a vida da tecnologia.

7







NASA: repositório de CAD/CAE/PDM, gerência de modelos, integração e
sistema colaborativo: We chose Python because it provides maximum
productivity, code that's clear and easy to maintain, strong and extensive
(and growing!) libraries, and excellent capabilities for integration with
other applications on any platform.
University of Maryland: ensino: I have the students learn Python in our
undergraduate and graduate Semantic Web courses. Why? Because
basically there's nothing else with the flexibility and as many web
libraries.
Maior case Python da atualidade (Help Gmail, GoogleGroups, etc...):
Python has been an important part of Google since the beginning, and
remains so as the system grows and evolves. Today dozens of Google
engineers use Python, and we're looking for more people with skills in this
language. -- Peter Norvig, director of search quality at Google, Inc.

8

Características básicas, características importantes.

9













Interpretada: usa máquina virtual, facilita portabilidade.
Interativa: pode-se programar interativamente, os comandos são
executados enquanto são digitados. Facilita testes, desenvolvimento
rápido e outros. Facilitadores estão presentes help(obj).
Orientada a Objetos: tudo1 é objeto: números, strings, funções, classes,
instâncias, métodos, ...
Fortemente Tipada: Não existe casts e nem conversão automática, não se
mistura tipos automagicamente.
Tipagem Dinâmica: A tipagem de um objeto é feita em
tempo de execução. Um objeto tem tipo, uma variável não.

10



Sintaxe clara, sem caracteres inúteis:








blocos são marcados por indentação
parênteses são opcionais, só precisam ser utilizados para
eliminar ambiguidades.
palavras-chave (keywords) e formações que ajudam na leitura,
como for ... in ....

Fácil extensão: codificar nos módulos é muito fácil, podendo








utilizar bibliotecas nativas, aproveitando desempenho,
características nativas das plataformas, etc.
API Python/C é bem simples
Diversos conversores automáticos (SWIG, SIP, ...)
Jython: usando Python em Java e vice-versa.
PyRex: pseudo linguagem para facilitar integração Python + C/C++.

11











Tipos básicos poderosos: listas, dicionários (hash tables), strings, ...
otimizados e de fácil uso.
Baterias Inclusas: biblioteca padrão contém diversos recursos úteis:
Interface Gráfica (Tk), XML, Servidores (TCP, UDP, HTTP, ...), HTML,
protocolos de internet (email, http, ...), xmlrpc, ...
Grande base de código e bibliotecas de terceiros
Grande comunidade de desenvolvedores
Software Livre: liberdade de uso, distribuição. Licença própria,
compatível com GPL, porém pode distribuir somente o binário.
Independente: a entidade sem fins lucrativos Python Software Foundation
cuida da propriedade intelectual do Python.

12

Python(x,y), interpretador, projeto.

13

Python (x,y) é um software livre para computação numérica, científica, de
engenharia, para análise de dados e visualização de dados baseado na
linguagem de programação Python, usando as interfaces gráficas do
usuário Qt e o ambiente de desenvolvimento integrado Eclipse.

O que é exatamente o Python (x,y)?
Python (x, y) é uma distribuição do científica-orientada do Python
baseada no Qt e Eclipse. Sua finalidade é ajudar os programadores
científicos que utilizam linguagens interpretadas (como MATLAB ou IDL) ou
linguagens compiladas (C/C++ ou Fortran), a mudar para Python.
Programadores de C/C++ ou Fortran vão apreciar poder reutilizar seus
códigos tal como estão usando um wrapper e podendo assim chamá-los
diretamente a partir de scripts em Python.

14

Atalhos:

Documentação:

15







Após iniciar um novo
projeto, deve-se
configurar o
interpretador Python.
Isso é feito indo em
windows > preferences
> PyDev > interpreter
Python
Basicamente, clica-se
em Auto Config e
após OK.

16

Sintaxe básica, comantários, identação, literais e operadores.

17

Um programa em Python é constituído de linhas lógicas:




Linhas Lógicas são terminadas com uma nova linha;
Exceto quando explicitamente continuadas na próxima linha física, para isto
usa-se o \.
Ou implicitamente continuadas na próxima linha física por expressões que
usam parênteses, colchetes ou chaves.

18





Após o caractere # até o final da linha, tudo é considerado um
comentário e ignorado, exceto pelos comentários funcionais.
Comentários funcionais geralmente são usados para:
alterar a codificação do arquivo fonte do programa acrescentando um comentário com
o texto #-*- coding: -*#- no inicio do arquivo, aonde é a
codificação do arquivo (cp1251 para português usando o windows PT-BR, utf-8 no
linux). Alterar a codificação é necessário para suportar caracteres que não fazem
parte da linguagem inglesa, no código fonte do programa.
definir o interpretador que será utilizado para rodar o programa em sistemas UNIX,
através de um comentário começando com #! no inicio do arquivo, que indica o
caminho para o interpretador (geralmente a linha de comentário será algo como
#!/usr/bin/env python).


19








Em Python, os blocos de código são delimitados pelo uso de indentação.
A indentação não precisa ser consistente em todo o arquivo, só no bloco
de código, porém é uma boa prática ser consistente no projeto todo.
Cuidado ao misturar TAB e Espaços: configure seu editor!
Utilitário tabnanny (geralmente está na instalação do seu python, como
/usr/lib/python2.3/tabnanny.py) verifica indentação.

20

saída

21









Devem começar com uma letra a-z, sem acentuação ou underline _.
Depois pode ser seguido por uma letra a-z, sem acentuação, dígitos e
underline _.
Alguns identificadores são palavras-chave reservadas:
and, del, for, is, raise, assert, elif, from,
lambda, return, break, else, global, not, try,
class, except, if, or, while, continue, exec,
import, pass, yield, def, finally, in, print
Python é case sensitive, ou seja, Maiúsculas e Minúsculas são diferentes!

22



Strings









Convencional: 'texto' ou "texto"
Multi-Line: '''texto várias linhas'''
ou """texto várias linhas"""
Unicode: u'texto unicode' ou u"texto", ...
Raw: r'texto bruto\n'
Strings em várias linhas são concatenadas.

Números parecido com outras linguagens, C, C++, Java:
Inteiro: 123 (decimal), 0632 (octal), 0xff00 (hexadecimal)
Longo: 123L ou 123l
Ponto Flutuante: 3.14, 10., .12, 1.23e-9
Complexos: 10.0 + 3j


23

Operador
Descrição
Método correspondente
+
adição
__add__
subtração
__sub__
*
multiplicação
__mul__
**
potenciação
__pow__
/
divisão
__div__
//
divisão por baixo (floor)
__floordiv__
%
módulo (resto)
__mod__
>
deslocamento à direita
__rshift__
&
"e" lógico (and) bit-a-bit
__and__
|
"ou" lógico (or) bit-a-bit
__or__
^
"ou exclusivo" (xor) bit-a-bit
__xor__
~
Inverte
__inv__
<
menor
__lt__
>
maior
__gt__
=
maior ou igual
__ge__
==
igual lógico
__eq__
!=
diferente lógico
__ne__

Para maiores informações import operator; help(operator).

24

Variáveis, controles de fluxos, laços e funções.

25







Python usa tipagem dinâmica: uma variável não tem tipo fixo, ela tem o
tipo do objeto que ela contém.
Para criar um novo conteúdo para a variável é necessário apenas uma
atribuição.
Um conteúdo é destruído e recolhido pelo coletor de lixo quando
nenhuma variável ou estrutura aponta mais para ele.

26



Utilizar o Python no modo interativo como calculadora e calcular:
250
250 . 3
250 . 3 - 1000
400.0
+ 50
250



Respostas:

27

Executando instruções de forma condicional do tipo
if :

elif :

elif :

else:

Sendo:
: sentença que possa ser avaliada como verdadeira ou falsa.
: seqüência de linhas de comando.
As clausulas elif e else são opcionais e podem existir vários elifs para o mesmo if.
Parênteses só são necessários para evitar ambigüidades.

28

Em Python

Sendo raw_input( ) o comando para a entrada pelo teclado em tempo de execução.
Usando diversas condições:

Apartir da versão 2.5, python suporta também o seguinte tipo de expressão:
= if else

29



Os operadores lógicos são: and, or, not, is e in.








and: retorna verdadeiro se e somente se receber duas expressões que forem verdadeiras.
or: retorna falso se e somente se receber duas expressões que forem falsas.
not: retorna falso se receber uma expressão verdadeira e vice-versa.
is: retorna verdadeiro se receber duas referências ao mesmo objeto e falso em caso contrário.
in: retorna verdadeiro se receber um item e uma lista e o item ocorrer uma ou mais vezes na
lista e falso em caso contrário.

Os seguintes valores são considerados falsos:










Os seguintes valores são considerados falsos:
False (falso).
None (nulo).
0 (zero).
'' (string vazia).
[] (lista vazia).
() (tupla vazia).
{} (dicionário vazio).
Outras estruturas com o tamanho igual a zero.

30



Implementar o seguinte conjunto de regras em Python:




Se a for verdadeiro e b for falso, imprima Caso 1
Senão, Caso a for falso e b for verdadeiro, imprima Caso 2
Caso contrário:
Caso c for maior que 10 e d estiver entre 0.0 e 100.0, imprima Caso 3
Caso e estiver na lista lst, imprima Caso 4
Senão imprima Caso 5

31



São dois tipos de laços em python:
while CONDICAO :
BLOCO_DE_CODIGO
for VARIAVEL in SEQUENCIA :
BLOCO_DE_CODIGO

Em python:

32





continue interrompe a execução da iteração atual e vai para a próxima,
se esta existir.
break interrompe a execução do laço.

Saída:

33



Visando facilitar a vida do programador, Python fornece a cláusula else para os
laços. Esta será executada quando a condição do laço for falsa, eliminando a
necessidade do programador manter uma variável de estado.
Saída:

Saída:

No exemplo acima, a mensagem Laço chegou ao fim só é imprimida
caso não existir um elemento que seja igual a parada.

34



Dada uma lista de palavras lista e uma palavra chave imprimir o índice do
elemento que encontrou a palavra, senão imprimir Palavra não encontrada.

Saída:

35





enumerate(sequencia) é um iterador que retorna pares (indice,
sequencia[indice])
Em python, a construção a seguir é válida:

Saída:



Então for índice, palavra in enumerate(lista) também é
válido!

36



Funções são blocos de código identificados por um nome, que podem
receber parâmetros pré-determinados.



No Python, as funções:










Podem retornar ou não objetos.
Aceitam Doc Strings.
Aceitam parâmetros opcionais (com defaults). Se não for passado o parâmetro
será igual ao default definido na função.
Aceitam que os parâmetros sejam passados com nome. Neste caso,a ordem em
que os parâmetros foram passados não importa.
Tem namespace próprio (escopo local), e por isso podem ofuscar definições de
escopo global.
Podem ter suas propriedades alteradas (geralmente por decoradores).

Doc Strings são strings que estão associadas a uma estrutura do Python.
Nas funções, as Doc Strings são colocadas dentro do corpo da função,
geralmente no começo. O objetivo das Doc Strings é servir de
documentação para aquela estrutura.

37



Sintaxe:
def NOME_DA_FUNCAO ( LISTA_DE_PARAMETROS ):
BLOCO_DE_CODIGO

Em python:

Saída:

38



Pode-se ter parâmetros com valores padrão, estes devem vir depois dos
parâmetros sem valor padrão.

Saída:

Cuidado!

O valor do padrão para um parâmetro é calculado somente uma vez
quando o programa é carregado, caso você use um objeto mutável, todas
as chamadas usarão a mesma instância.

39



Exemplo do objeto mutável:
Saída:



Talvez seja este o comportamento que você quer, mas talvez não. Caso deseje
que uma nova instância seja criada para cada chamada, utilize algo como:

Saída:
ou

40



Argumentos sem nome: os argumentos são passados para a função na forma de
uma lista, na ordem em que foram digitados:
Saída:



Argumentos com nome: os argumentos são passaos para a função na forma de
um dicionário, o nome do argumento é a chave.
Saída:



Usando Ambos:
Saída:

41



Faça uma função que dado um número, retorne o próximo na sequência de
Robert Morris (http://www.ocf.berkeley.edu/~stoll/number_sequence.html)
1, 11, 21, 1211, 111221, ...

Saída:

42



Um bloco vazio é criado com o keyword pass



Qualquer string solta (não atribuéda a variáveis) é considerada uma
docstring e contribui para a documentação do bloco, no atributo
__doc__:

43

Números, Sequências (listas, tuplas, dicionários), Mapeamento e
Strings.

44



Python oferece alguns tipos numéricos na forma de builtins:
Inteiro (int): i = 1
Real de ponto flutuante (float): f = 3.14
Complexo (complex): c = 3 + 4j




Além dos números inteiros convencionais, existem também os inteiros
longos, que tem dimensão arbitrária e são limitados pela memória
disponível. As conversões entre inteiro e longo são realizadas de forma
automática. A função builtin int() pode ser usada para converter outros
tipos para inteiro, incluindo mudanças de base.

45



Exemplo:

Saída:



Os números reais também podem ser representados em notação
cientifica, por exemplo: 1.2e22.

46





O Python tem uma série de operadores definidos para manipular
números, através de cálculos aritméticos, operações lógicas (que testam se
uma determina condição é verdadeira ou falsa) ou processamento bit-abit (em que os números são tratados na forma binária).
Operações aritméticas:

Soma (+).

Diferença (-).

Multiplicação (*).

Divisão (/): entre dois inteiros funciona igual à divisão inteira. Em
outros casos, o resultado é real.

Divisão inteira (//): o resultado é truncado para o inteiro
imediatamente inferior, mesmo quando aplicado em números reais,
porém neste caso o resultado será real também.

Módulo (%): retorna o resto da divisão.

Potência (**): pode ser usada para calcular a raiz, através de
expoentes fracionários (exemplo: 100 ** 0.5).

Positivo (+).

Negativo (-).



Operações lógicas:

Menor ().

Menor ou igual (=).

Igual (==).

Diferente (!=).



Operações bit-a-bit (bitwise):

Deslocamento para esquerda ().

E bit-a-bit (&).

Ou bit-a-bit (|).

Ou exclusivo bit-a-bit (^).

Inversão (~).

47





Durante as operações, os números serão convertidos de forma adequada
(exemplo: (1.5+4j) + 3 resulta em 4.5+4j).
Além dos operadores, também existem algumas funções builtin para lidar
com tipos numéricos: abs(), que retorna o valor absoluto do número, oct(),
que converte para octal, hex(), que converte para hexadecimal, pow(),
que eleva um número por outro e round(), que retorna um número real
com o arredondamento especificado.

Saída:

48



Operadores de atribuição:


=

Operador de atribuição simples ( c = a + b vai atribuir o valor de a

+ b em c).











+=
-=
*=
/=
%=
**=
//=

Adiciona e atribui (c += a é equivalente a c = c + a).
Subtrai e atribui ( c-= a é equivalente a c = c ­ a)
Multiplica e atribui (c *= a é equivalente a c = c * a)
Divide atribui (c /= a é equivalente a c = c / a)
Usa o módulo e atribui (c %= a equivale a c = c % a)
Calcula o expoente atribui (c **= a é equivalente a c = c ** a)
Divisão por baixo e atribui (c //= a é equivalente a c = c // a)

49



Listas são coleções heterogêneas de objetos, que podem ser de qualquer
tipo, inclusive outras listas. As listas no Python são mutáveis, podendo ser
alteradas a qualquer momento.
Criação de uma lista:



Acessando elementos pelo índice:



Saída:


Mudando elementos já existentes (a posição já deve existir):
Mostrando a lista:



Acessando pedaços da lista:
Mostrando as novas listas:

50



Acrescentando mais um item ao final da lista:
Saída:



Estendendo a lista com outra:
Saída:



Ordenando a lista (altera as posições na lista):
Saída:



Invertendo a lista (também altera as posições):
Saída:



Contar ocorrências de um elemento:
Saída:



Mostrando a posição do elemento na lista CORRIGIR index():
Saída:



Inserir um elemento em certa posição na lista:
Saída:



Apagando um elemento da lista:
Saída:



Apagando um pedaço da lista:
Saída:



Apagando certo elemento na lista:
Saída:



Mudando um pedaço da lista:
Saída:



Repetindo uma lista:
Saída:



Mostrando o tamanho da lista:
Saída:



Criando uma lista numerada com as posições:
Saída:



Criando uma lista numerada com as posições em formato string:
Saída:



Criando uma lista com o índice ao quadrado, mas somente se for múltiplo
de 2:
Saída:



Criando uma lista de de 0 a 30 indo de 10 em 10:
Saída:



Juntando duas listas formando tuplas (as listas não precisam ter o mesmo
tamanho, no entanto as tuplas se formarão até o tamanho da menor lista):
Saída:



Somando os elementos de uma lista:
Saída:



Esses são as principais operações com listas. Para mais informações:
help(list) no console do python ou
http://www.python.org/doc/2.3/lib/typesseq-mutable.html ou
http://docs.python.org/tutorial/datastructures.html


1.

Crie uma lista lista, verifique se valor está dentro dela, caso verdade
imprima Sim, senão imprima Não.

2.

Crie outra lista. Uma lista lista, itere sobre a lista, imprimindo cada um
de seus elementos.

3.

Usando a lista de 10 componentes, cada componente com o valor do seu
indice, crie uma nova lista rotaciona_3 que cada posição está
rotacionada, ou corrida, ou caminhada na lista em 3 posições para a
esquerda, por exemplo, o índice zero ficaria:
0 = 0 + 3
Dica: existe uma forma simples de se fazer isso em python.







Semelhantes as listas, porém são imutáveis: não se pode acrescentar,
apagar ou fazer atribuições aos itens.
Criação da tupla:
Saída:
Mostrando elemento:
Outros exemplos:
Saídas:



Tuplas podem ser convertidas em listas e vice-versa:
Saídas:



As tuplas são mais eficientes do que as listas convencionais, pois
consomem menos recursos computacionais.







Um dicionário é uma lista de associações compostas por uma chave única
e estruturas correspondentes. Dicionários são mutáveis, tais como as listas.
A chave tem que ser de um tipo imutável, geralmente strings, mas também
podem ser tuplas ou tipos numéricos. O dicionário do Python não fornece
garantia de que as chaves estarão ordenadas.
Estrutura:
Elementos
Imutáveis



Chaves

Valores

Material

Aço

Young

210e9

Limites

(210,380)

(0, 0)

(30,190)

Objetos
quaisquer

Criação:

57



Acessando elementos:
Saída:



Adicionando elementos (a chave precisa sem imutável, p. ex. n pode ser
uma lista):

Saída:


Apagar um elemento do dicionário:



Apagar completamente o dicionário:

58



Obtendo itens chaves e valores:

Saída:



Obtendo iteradores (otimizado para for):
Saída:

59



Crie um dicionário simulação e coloque nele os dados de uma simulação
de elementos finitos: material, elemento, dof, força, apoio



Usando o dicionário criado anteriormente, imprima material e acrescente
modos ao dicionário com o valor de 5 e exclua a chave dof.



Também usando simulação, imprima todos os itens do dicionário no
formato chave : valor, ordenado pela chave.

60



As strings no Python são buitins para armazenar texto. São imutáveis,
sendo assim, não é possível adicionar, remover ou mesmo modificar algum
caractere de uma string. Para realizar essas operações, o Python precisa
criar um nova string.



Tipos:
String padrão: s = ,,Led Zeppelin
String unicode: u = uBjörk


A string padrão pode ser convertida para unicode através da função
unicode().


A inicialização de strings pode ser:
Com aspas simples ou duplas.
Em várias linhas consecutivas, desde que seja entre três aspas simples ou duplas.
Sem expansão de caracteres (exemplo: s = r'\n', aonde s conterá os caracteres \ e
n).




Criação:
Saída:



Acesso a elementos pelo índice:
Saída:



Acesso a pedaços da string:
Saída:



Funções de procura por substrings:


No início:

Saída:


No final:

Saída:


Em qualquer posição:

Saída:



Funções de verificação de conteúdo:


Se são somente letras:

Saída:


Se são somente números:

Saída:


Se são letras e números:

Saída:


Se são somente espaços:

Saída:



Transformar sequência em texto e texto em sequência:


Juntando textos de uma lista em um texto só:

Saída:


Quebrando um texto em uma lista:

Saída:


Transformar a caixa do texto (será criada uma nova instância):


Para maiúscula:

Saída:


Para minúscula:

Saída:


Inverter maiúsculas e minúsculas:

Saída:



Verificar se está em maiúscula, minúscula, com a primeira letra maiúscula:

Saída:



Retirada de caracteres (será criada uma nova instância):


Da esquerda:

Saída:


Da direita:

Saída:


De ambos os lados:

Saída:



Troca de caracteres (será criada uma nova instância):


Troca de pedaços:

Saída:


Troca de caracteres individuais baseados em uma tabela:

Saída:



Formatação de strings:






Operador % é usado para fazer a formatação da string.
O formato deve seguir a convenção do printf() do C.
Pode-se usar valores nomeados, passando um dicionário.
Operadores extra, como o "%r" são usados para a representação do objeto.
Mais informações em http://docs.python.org/lib/typesseq-strings.html (item 6.6.2).





Operador % é usado para fazer interpolação de strings. A
interpolação é mais eficiente no uso de memória do que a concatenação
convencional.
Símbolos usados na interpolação:










%s: string.
%d: inteiro.
%o: octal.
%x: hexacimal.
%f: real.
%e: real exponencial.
%%: sinal de percentagem.

Os símbolos podem ser usados para apresentar números em diversos
formatos.



Exemplos:

Saída:



A partir da versão 2.6, está disponível outra forma de interpolação além
do operador %, o método de string e a função chamados format().

Saída:

1.

2.
3.

4.

5.

Converta uma string para maiúscula e imprima.
Dado o texto abacate troque as letras a por 4 e imprima.
Dado o texto bin:x:1:1:bin:/bin:/bin/false, quebre-o na ocorrência de
':'.
Dado uma tupla ('a', 'b', 'c'), transforme-a em uma string, separada por
'*'.
Uma mensagem está criptografada usando o ROT13:
fr ibpr rfgn yraqb rfgr grkgb, cnenoraf. pnfb anb graun hgvyvmnqb b
genafyngr(), gragr qrabib!.
Decodifique essa mensagem considerando somente letras minúsculas.
ROT13 ou rotate by 13 places é um esquema de substituição de cifras,
bastante usado em foruns on-line. Mais sobre esse esquema em:
http://en.wikipedia.org/wiki/ROT13

Matemática, Arquivos, Sistemas de arquivo, Arquivos compactados,
Arquivos de dados, Sistema operacional, Tempo, Expressões
regulares.

72

É comum dizer que o Python vem com baterias inclusas, em referência a
vasta biblioteca de módulos e pacotes que é distribuída com o
interpretador.
Alguns módulos importantes da biblioteca padrão:









Matemática: math, cmath, decimal e random.
Sistema: os, glob, shutils e subprocess.
Threads: threading.
Persistência: pickle e cPickle.
XML: xml.dom, xml.sax e elementTree (a partir da versão 2.5).
Configuração: ConfigParser e optparse.
Tempo: time e datetime.
Outros: sys, logging, traceback, types e timeit.



Além dos tipos numéricos builtins do interpretador, na biblioteca padrão
do Python existem vários módulos dedicados a implementar outros tipos e
operações matemáticas.
O módulo math define funções logarítmicas, de exponenciação, trigonométricas,
hiperbólicas e conversões angulares, entre outras.
O módulo cmath, implementa funções similares, porém feitas para processar números
complexos.


Saída:



O módulo random traz funções para a geração de números aleatórios.

Saída:



Na biblioteca padrão ainda existe o módulo decimal, que define
operações com números reais com precisão fixa.

Saída:


Com este módulo, é possível reduzir a introdução de erros de
arredondamento originados da aritmética de ponto flutuante.



Na versão 2.6, também está disponível o módulo fractions, que trata de
números racionais.

Saída:



As frações podem ser inicializadas de várias formas: como string, como
um par de inteiros ou como um número real. O módulo também possui
uma função chamada gcd(), que calcula o maior divisor comum (MDC)
entre dois inteiros.





Os arquivos no Python são representados por objetos do tipo file, que
oferecem métodos para diversas operações de arquivos. Arquivos podem
ser abertos para leitura ('r', que é o default), gravação ('w') ou adição
('a'), em modo texto ou binário('b').
Em Python:
sys.stdin representa a entrada padrão.
sys.stdout representa a saída padrão.
sys.stderr representa a saída de erro padrão.








A entrada, saída e erro padrões são tratados pelo Python como arquivos
abertos. A entrada em modo de leitura e os outros em modo de
gravação.
Os objetos do tipo arquivo também possuem um método seek(), que
permite ir para qualquer posição no arquivo.
Na versão 2.6, está disponível o módulo io, que implementa de forma
separada as operações de arquivo e as rotinas de manipulação de texto.



Exemplo de escrita:

Saída:



Exemplo de leitura:

Saída:



Os sistemas operacionais modernos armazenam os arquivos em estruturas
hierárquicas chamadas sistemas de arquivo (file systems).



Várias funcionalidades relacionadas a sistemas de arquivo estão
implementadas no módulo os.path, tais como:
os.path.basename(): retorna o componente final de um caminho.
os.path.dirname(): retorna um caminho sem o componente final.
os.path.exists(): retorna True se o caminho existe ou False em caso contrário.
os.path.getsize(): retorna o tamanho do arquivo em bytes.




O glob é outro módulo relacionado ao sistema de arquivo. A função
glob.glob() retorna uma lista com os nomes de arquivo que atendem ao
critério passado como parâmetro. (semelhante ao dir no prompt do
windows, ou ls no terminal do linux)



Exemplo:

Saída:



O Python possui módulos para trabalhar com vários formatos de arquivos
compactados.



Exemplo de gravação de um arquivo .zip:



Exemplo de leitura de um arquivo .zip:

Saída:



Na biblioteca padrão, o Python também fornece um módulo para
simplificar o processamento de arquivos no formato CSV (Comma
Separated Values). No formato CSV, os dados são armazenados em
forma de texto, separados por vírgula, um registro por linha.

Saída:



Saída:

Além do sistema de
arquivos, os módulos
da biblioteca padrão
também fornecem
acesso a outros
serviços providos pelo
sistema operacional.



O Python possui dois módulos para lidar com tempo:
time: implementa funções que permitem utilizar o tempo gerado pelo sistema.
datetime: implementa tipos de alto nível para realizar operações de data e hora.


Saída:

time.struct_time(tm_year=2010, tm_mon=3, tm_mday=7, tm_hour=18, tm_min=1, tm_sec=22, tm_wday=6, tm_yday=66, tm_isdst=0)
Sun Mar 07 18:01:22 2010
1267995682.75 -> time.struct_time(tm_year=2010, tm_mon=3, tm_mday=7, tm_hour=21, tm_min=1, tm_sec=22, tm_wday=6, tm_yday=66,
tm_isdst=0)



Saída:

Continuando...

1268010082.0 -> time.struct_time(tm_year=2010, tm_mon=3, tm_mday=7, tm_hour=22, tm_min=1, tm_sec=22, tm_wday=6, tm_yday=66,
tm_isdst=0)
O programa levou 3.831203312e-07 segundos até agora...
1 segundo(s)
2 segundo(s)
3 segundo(s)
4 segundo(s)
5 segundo(s)



Em datetime, estão definidos quatro tipos para representar o tempo:
datetime: data e hora.
date: apenas data.
time: apenas hora.
timedelta: diferença entre tempos.


Saída:



Expressão regular é uma maneira de identificar padrões em sequências
de caracteres.



Principais caracteres:


















Ponto (.): Em modo padrão, significa qualquer caractere, menos o de nova linha.
Circunflexo (^): Em modo padrão, significa inicio da string.
Cifrão ($): Em modo padrão, significa fim da string.
Contra-barra (\): Caractere de escape, permite usar caracteres especiais como se fossem comuns.
Colchetes ([]): Qualquer caractere dos listados entre os colchetes.
Asterisco (*): Zero ou mais ocorrências da expressão anterior.
Mais (+): Uma ou mais ocorrências da expressão anterior.
Interrogação (?): Zero ou uma ocorrência da expressão anterior.
Chaves ({n}): n ocorrências da expressão anterior.
Barra vertical (|): ou lógico.
Parenteses (()): Delimitam um grupo de expressões.
\d: Dígito. Equivale a [0-9].
\D: Não dígito. Equivale a [^0-9].
\s: Qualquer caractere de espaçamento ([ \t\n\r\f\v]).
\S: Qualquer caractere que não seja de espaçamento.([^ \t\n\r\f\v]).
\w: Caractere alfanumérico ou sublinhado ([a-zA-Z0-9_]).
\W: Caractere que não seja alfanumérico ou sublinhado ([^a-zA-Z0-9_]).



Exemplo:

Saída:

1.

Crie um arquivo compactado contendo um arquivo de texto com uma lista de
dados de plataforma, usuário, o diretório de trabalho e a data e hora completas
do momento da operação no formato do sistema, em cada linha do arquivo.

2.

Converta os segundos armazenados no exercício 1 para hexadecimal e octal.

3.

Converta o número complexo 3.45 + 2.3j para a forma polar, com o ângulo em
graus, multiplique esse ângulo a um numero real randômico entre 0 e 1 e mostre
na tela com 2 casas decimais.

4.

Salve os dados dos exercícios 2 e 3 em um arquivos de dados do tipo CSV, com a
descrição de cada dado.

Referências:
Python para Desenvolvedores / Luiz Eduardo Borges
Rio de Janeiro, Edição do Autor, 2010
ISBN 978-85-909451-1-6
Livro licenciado sob uma Licença Creative Commons Atribuição-Uso NãoComercial-Compartilhamento pela mesma Licença 2.5 Brasil.
Para ver uma cópia desta licença, visite http://creativecommons.org/licenses/bync-sa/2.5/br/ ou envie uma carta para Creative Commons, 171 Second Street,
Suite 300, San Francisco, California 94105, USA.
Site oficial
A edição mais recente está disponível no formato PDF em:
http://ark4n.wordpress.com/python/