Posts tagged programação

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

JNI – fazendo o Java ficar rápido

Duke tocando guitarraPassei esses dias procurando um bom tutorial de JNI mas tudo que eu achei era muito complicado e voltado para versões mais antigas do Java.

JNI é o jeito padrão de fazer com que uma aplicação Java chame implementações nativas, o que pode ser muito bom em eficiência.

Demorou um bocado mas eu finalmente consegui fazer um Olá Mundo em JNI e eu escrevi um tutorial de como fazer um olá mundo em JNI.

Java como programar, download pdf grátisQuer ir mais longe? Livros! Pesquise os menores preços de livros de programação em Java no Buscapé.

Uma pilha em C

Pilha humana human stack man stack mens in a stack human towerO C não oferece um bom conjunto de estruturas já embutido na linguagem.

Eu estou sempre a escrever estruturas como lista encadeada, fila e pilha. Eu perco esses códigos e depois acabo escrevendo denovo. Para que isso não aconteça mais comigo e para que outras pessoas não passem por isso eu vou gradualmente começar a disponibilizar esse tipo de código sempre que eu implementalos.

Para começar uma pilha escrita em C (eu e o Marco fizemos esses fim de semana) que você pode usar em pequenas aplicações.

Como é de costume meu e do marco, está tudo no que nos acreditamos ser C padrão e portanto pode ser compilado em qualquer lugar.

Garota no computador

Quer ir mais longe? Livros! Pesquise os melhores preços de livros sobre programação no 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é.