Escrevi 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.

• 0 Comentários

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.

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:

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:

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.

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

• 11 Comentários

O Vim possui suporte a sintaxe colorida mas muitas vezes essa opção vem desabilitada por padrão.

No arquivo /etc/vim/vimrc procure a linha:

“syntax on

retire o ” para ficar assim:

syntax on

Um texto que você veria assim:

Passa a ser visto assim:

Bem melhor.

Se você não tiver acesso ao arquivo /etc/vim/vimrc você pode criar um arquivo com o nome .vimrc na raiz do seu diretório e colocar a “syntax on” lá.

Se você quiser simplesmente ativar a sintaxe estando dentro do vim, aperte a tecla de escape e digite :syntax on.

Páscoa está chegando! Hora de comprar ovos de chocolate!

Veja os ovos de páscoa mais baratos e os mais caros. Buscapé.

• 6 Comentários

Tem uma coisa bem específica que eu sempre preciso fazer é preencher um número com zeros à esquerda.

Preenchendo com 3 zeros por exemplo temos que 1 fica 001, 50 fica 050 e 200 fica inalterado. Pra que fazer isso? Geralmente para exibir melhor matrizes.

Em Python há um comando bem fácil para isso, o método zfill da classe string:

>>> a = 15
>>> print str(a).zfill(3)
015
>>> b = 'x'
>>> print b.zfill(2)
0x


Em C o printf consegue fazer coisa parecida:

#include<stdio.h>
int main(){
int a = 15;
printf("%03d\n", a);
printf("%04d\n", a);
}


Isso dá uma saída:

015
0015

Para fazer o mesmo com strings em C, você pode tentar o sprintf.

Uma ótima maneira de aprender mais são com livros de Como Programar em Python pelos menores preços que você encontra no Buscapé.

• 0 Comentários