Posts tagged Python

Persistência em Python, criando uma agenda simples

Prateleira ShelvePersistência, em programação, é guarda alguma informação para você pegar depois.

A solução mais comum para persistência de dados são os bancos de dados, que podem resolver esse problema de uma maneira sofisticada e eficiente.

Por outro lado, para usar um banco de dados você vai precisar:

  • Instalar um banco de dados
  • Aprender a linguagem de consulta do banco de dados, geralmente SQL.
  • Fazer a ligação do banco de dados com a linguagem que você está usando.

Tudo isso é chato e complicado, ainda mais se você quer fazer algo bem simples onde o desempenho não é um fator crítico. Você também poderia guardar suas informações num arquivo mas você teria que tratar vários aspectos de baixo nível.

Python tem algumas maneiras simples e fáceis de tratar persistência. Uma delas é o Shelve, que é um módulo padrão do Python.

Para brincar com ele abra seu terminal python digitando python no seu console:

>>> import shelve
>>> arq = shelve.open(‘asdf’)
>>> arq['site'] = ‘http://www.python.org’
>>> arq['pi'] = 3.1415
>>> arq['fibo'] = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
>>> print arq['pi']
3.1415
>>> print arq['fibo']
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
>>> del arq['site']

import shelve vai importa o módulo shelve. arq vai receber o arquivo asdf, que se não existir vai ser criado. Depois disso você pode usar arq como um dicionário comum, indexado por uma string chave. Para deletar alguem do arquivo simplesmente dê um del arq[chave].

Experimente fechar seu console e olhar como ficou o diretório onde você executou o terminal Python:

Gnome: olhando como ficou o diretório

Um arquivo asdf foi criado. Você não precisa se preocupar como esses dados estão guardados dentro desse arquivo, o shelve vai cuidar disso para você.

Agora se você abrir novamente o console dentro desse diretório:

>>> import shelve
>>> arq = shelve.open(‘asdf’)
>>> for chave in arq:
… print chave, arq[chave]

fibo [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
pi 3.1415

Tadã! Seus dados de volta.

Fica bem mais fácil fazer programas com persistência agora não é?

Livros Python Vá mais longe! Livros de Como Programar em Python pelos menores preços.

Buscapé.

More >

Livro Python Guia de Bolso

Livros de bolso em geral são ótimos.

Livro Python Guia de Bolso download pdf

Eu estava querendo comprar um bom livro de Python mas devido a fortes cortes na minha verba destinada a literatura técnica, teve que ser um livro de bolso mesmo.

Mas livros de bolso e cartões de referência tem suas vantagens, são pequenos, baratos, leves e vão direto ao assunto.

É chato ter um livro que pesa como um halteres e que na prática você só vai precisar mesmo para consulta.

O livro que eu comprei, e já li, e que está aí na foto é o Python Guia de Bolso do Mark Lutz, da O’Reilly e públicado no Brasil pela Alta Books.

O livro em si é muito bom, trata desde assuntos básicos como operações com listas, tuplas, strings, arquivos, passando pela sintaxe da linguagem e tocando em assuntos como Tkinter, Banco de Dados, persistência de objetos, expressão regular e alguns modulos padrão do Python.

Esse livro somado a um console Python, é diversão garantida. Outro item a favor dele é que ele ficou pequeno e leve, realmente um livro de bolso.

Os contras desse livro ficam por conta da edição brasileira. A tradução é péssima, são incontáveis erros. Alguns comandos que deveriam ter sido escrito em inglês foram traduzidos, algumas coisas que deveriam ter sido traduzidas não foram.

A coisa tá bizarra. Tá bizarra e perdeu um Schnauzer na minha avaliação. Tá certo que o livro original não tem esses problemas, mas é uma forma que eu tenho de dar um puxão de orelha nessas editoras que fazem essas traduções preguiçosas.

O veredicto é:

4 Schnauzers

Ganhou uma nota boa, mas é porque o Python ajudou e o livro tá muito barato. Eu comprei o meu por menos de R$ 20,00 aqui na minha cidade.

Livros PythonPesquise os menores preços desse e outros livros de Python e saia programando por aí. Buscapé.

Espiral de Ulam

Uma coisa que andei brincando esses dias.

Um certo dia um senhor chamado Stanislaw Ulam, entediado durante um encontro científico, começou a rabiscar números em um papel para se distrair. Ele começou colocando o 1 no centro e fazer uma espiral de números ao redor dele:

Numeros em uma espiral

Depois ele decidiu destacar aqueles números que eram primos. Um número é primo se só tem dois divisores, que são 1 e o próprio número. O número 7 é primo porque só pode ser dividido por 1 e por 7. O número 4 não é primo porque pode ser dividido por 1, 2 e 4. Esse método de desenhar os primos é chamada de Espiral de Ulam.

Espiral com os primos em destaque

Essa foi a espiral até 49. Oh! E essas diagonais? Vamos continuar o mesmo processo, mas agora indo um pouco mais longe. Uma grade onde o centro representa o número 1 da espiral, deixando os números primos em preto e os não primos em branco.

Espiral de Ulam com 100 pontos por 100 pontos
Espiral de Ulam no intervalo de 1 à 10.000

Notou que apareceram algumas diagonais? O nosso senso comum nos diz que elas não deveriam estar aí, que a distribuição dos números primos, mesmo em uma espiral, deveria ser aleatória. Note a diferença de uma espiral com números escolhidos ao acaso e da espiral de ulam;

Espiral de Ulam à esquerda e aleatória a direita
Espiral de Ulam à esquerda e aleatória a direita. Com 40.000 pontos.

Eu fiz um programinha em Python (ulam.py) para gerar uma espiral de Ulam de um tamanho arbitrário. Gerar esse gráfico é bem pesado, para gerar o desenho de 5000 pixels por 5000 pixels levou 27 minutos.

Clique aqui para ver essa imagem, um intervalo de 25.000.000. Cuidado a imagem tem mais de 1Mb de tamanho.

Legal né?

Garota lendo livroAinda acha que primo é o filho da sua tia? Dê uma olhadinha nesses livros de matemática baratinhos. Buscapé.

PIL: Python Imaging Library

python1.gifEscrevi um tutorial sobre a Python Imaging Library que pode ser muito útil.

Com ele você faz coisas em Python semelhantes as que você faria em PHP com a GD.

Clique aqui para ler o tutorial, está na seção de estudos.

Sobrecarga de operadores em Python

Sobrecarga de operadores é uma maneira muito elegante de implementar uma álgebra simples para suas classes. Por exemplo os números racionais. Um racional são dois inteiros na forma a/b. a é um inteiro e b é um inteiro diferente de zero.

Atualização em 29 de Maio de 2012: aparentemente no post inteiro e no código também o significado de divisor e dividendo estão trocados! Fiquem a vontade para postar nos comentários suas versões com o código correto.

Uma classe em Python que modela o comportamento dos racionais:

class Racional:
   def __init__(self, divisor, dividendo):
      self.divisor = divisor
      self.dividendo = dividendo

   def __str__(self):
      return str(self.divisor) + '/' + str(self.dividendo)

Programa 1 – Classe Racional com saída em string da forma a/b

Salvando esse código como Racional.py podemos chama-lo assim:

>>> from Racional import *
>>> a = Racional(1,2)
>>> print a
1/2

O que fizemos foi chamar o modulo Racional, instanciar um Racional com divisor 1 e dividendo 2 e depois mandamos imprimi-la. A string de saída foi “1/2″. Agora um código um pouco mais interessante:

class Racional:
   def __init__(self, divisor, dividendo):
      self.divisor = divisor
      self.dividendo = dividendo

   def __str__(self):
      return str(self.divisor) + '/' + str(self.dividendo)

   def __mul__(self, outro):
      divisor = self.divisor*outro.divisor
      dividendo = self.dividendo*outro.dividendo
      return Racional(divisor, dividendo)

Programa 2 – Classe Racional com sobrecarga do operador *

Um exemplo de uso do programa 2:

>>> from Racional import *
>>> a = Racional(1,2)
>>> b = Racional(3,4)
>>> c = a*b
>>> print c
3/8

O que nós fizemos foi instanciar dois racionais, a é 1/2 e b é 3/4. c é a multiplicação de a com b.
A operação de multiplicação de racionais foi feita da seguinte forma:

Figura com a multiplicação de dois racionais

Quando definimos o método __mul__() estamos fazendo a sobrecarga do operador *. O método __mul__ sempre vai exigir dois parâmetros, o self que é o próprio objeto que está à esquerda do operador e outro objeto que eu chamei de outro, ele vai estar à direita do operador *.

É importante notar que um método de sobrecarga pede para que você retorne uma nova instância da classe Racional. Essa nova instância é o objeto que representa a multiplicação dos dois objetos anteriores, no caso, a e b.

Talvez você ainda não tenha se dado conta da beleza desse pequeno código. Num código em C ou Pascal (ou até mesmo em C++ ou Java quando não bem escrito) o mesmo código provavelmente seria assim:

a = Racional(1,2)
b = Racional(3,4)
c = a.soma(b)

ou coisa pior como funções somaRacionais(). No nosso código toma a semântica do operador * ficou encapsulada dentro da classe. Isso é lindo. :-)

Vamos fazer mais uma sobrecarga, a do operador +:

class Racional:
   def __init__(self, divisor, dividendo):
      self.divisor = divisor
      self.dividendo = dividendo

   def __str__(self):
      return str(self.divisor) + '/' + str(self.dividendo)

   def __mul__(self, outro):
      divisor = self.divisor*outro.divisor
      dividendo = self.dividendo*outro.dividendo
      return Racional(divisor, dividendo)

   def __add__(self, outro):
      divisor = self.divisor * outro.dividendo + outro.divisor * self.dividendo
      dividendo = self.dividendo * outro.dividendo
      return Racional(divisor, dividendo)

Programa 3 – Agora com o operador +
Podemos usar esse código assim:

>>> from Racional import *
>>> a = Racional(1,2)
>>> b = Racional(3,4)
>>> c = a+b
>>> print c
10/8

O que fizemos foi instanciar os mesmos a e b de antes mas agora c foi criado somando a e b. A operação foi efetuada assim:

Soma de dois racionais

Para fazer a sobrecarga do + usamos o método __add__ que recebeu dois parâmetros, o objeto self (ele mesmo) e o objeto outro.

Pronto, acho que agora você já sabe como fazer sobre carga de operadores. Alguns métodos que você pode sobrecarregar:

  • __add__: Adição. A+B
  • __sub__: Sutração. A-B
  • __mul__: Multiplicação. A*B
  • __div__: Divisão. A/B
  • __mod__: Resto da divisão. A%B
  • __pos__: Identidade. +A
  • __neg__: Negativo. -A
  • __abs__: Absoluto. |A|

Existem muitos, muitos outros métodos que você pode sobrecarregar. Esses foram aí de cima são só alguns dos métodos numéricos.

Livros Python Promoção! Livros de Como Programar em Python pelos menores preços você encontra no Buscapé.