Conhecendo os Dicionários

Hoje vamos dar uma olhada nos dicionarios, um tipo de dados do Python. Vamos começar por sua sintaxe:

d = {'nome' : 'igor', 'idade' : 18, 'curso' : 'python' }

Os dicionarios guardam pares de chave/valor, no caso acima, as chaves sao: 'nome', 'idade' e 'curso'... e elas se referem a seus respectivos valores: 'igor', 18, 'python'.
É importante lembrar que as posições dos pares chave/valor não tem ordem fixa. Os valores podem ser de qualquer tipo, strings, inteiros, tuplas.

Acima criamos o dicionario 'd' da maneira mais clássica, mas existem outras, como a função 'dict':

>>> items = [('nome','igor'), ('idade', 18), ('curso','python')]
>>> d = dict(items)
>>> d
{'idade': 18, 'curso': 'python', 'nome': 'igor'}

Outra maneira interessante de se criar um dicionario, é usando o método 'fromkeys'

>>> dic = {}.fromkeys(['nome','idade'])
{'idade': None, 'nome': None}

Ao invés de None, podemos dar o valor padrão

>>> dic = {}.fromkeys(['nome','idade'],'NADA')
>>> dic
{'idade': 'NADA', 'nome': 'NADA'}

Agora vamos ao que mais interessa, manusear o dicionário...

>>> d['nome']
'igor'

Tem um pequeno problema, e se essa chave nao existisse?

>>> d
{'idade': 18, 'curso': 'python', 'nome': 'igor'}
>>> d['profissao']
Traceback (most recent call last):
File "", line 1, in ?
KeyError: 'profissao'

Pra evitar esse tipo de bug, existe o metodo 'get'

>>> d
{'idade': 18, 'curso': 'python', 'nome': 'igor'}
>>> d.get('nome')
'igor'
>>> print d.get('profissao')
None

Pra alterar o valor de uma chave é muito simples

>>> d['nome']
'igor'
>>> d['nome'] = 'sobreira'
>>> d['nome']
'sobreira'

Observe que eu substitui o valor da chave 'nome', e caso ela ainda não existisse, eu teria acabado de criá-la. Mas que tal verificar se determinada chave existe mesmo?

>>> 'nome' in d
True
>>> 'profissao' in d
False
>>> d.has_key('nome')
True

Pra apagar uma chave também é batante simples:

>>> d
{'curso': 'python', 'nome': 'igor', 'idade': 18}
>>> del d['nome']
>>> d
{'idade': 18, 'curso': 'python'}

Caso você queira ver o que está apagando, ao invés do 'del', pode usar o 'pop'

>>> d
{'idade': 18, 'curso': 'python'}
>>> d.pop('curso')
'python'

Mas eu não quero apagar so uma chave, quero limpar todo o dicionario. Pra isso tem o 'clear'

>>> d = {'nome': 'igor', 'curso': 'python'}
>>> d.clear()
>>> d
{}

Também podemos copiar todo o conteudo do dicionario, para um outro dicionario

>>> d = {'nome': 'igor', 'curso': 'python'}
>>> d2 = d.copy()
>>> d2
{'curso': 'python', 'nome': 'igor'}
>>> d2['curso'] = 'dicionarios'
>>> d2
{'curso': 'dicionarios', 'nome': 'igor'}
>>> d
{'curso': 'python', 'nome': 'igor'}

Observe que uma alteração em um, não altera o conteudo do dicionario copiado

Existe uma utilidade muito legal dos dicioanários, que é formatar string. Aqui vai um exemplo muito interessante

>>> dic = {'nome': 'igor', 'curso': 'python'}
>>> frase = 'meu nome e %(nome)s e estou estudando %(curso)s'
>>> print frase % dic
meu nome e igor e estou estudando python


Bem, espero ter esclarecido um pouco o uso de dicionarios.
Tomei como base o livro Begining Pyhton - From Novice to Professional, de Magnus Lie Hetland, que eu aconselho muito pra quem ta começando na linguagem.
Até a próxima...

Python Orientado a Objetos

Hoje vai a primeira dica enviada por um visitante do blog, um amigo, Flavio Ribeiro. Foi ele quem me aprensentou a linguagem Python, quando começamos o curso de Sistemas em Telecomunicações no CEFET-PB, e assim como eu, adora a linguagem e quer aprender cada vez mais sobre ela.

Bem, Python é uma linguagem Orientad a Objetos, e aqui Flavio dar uma introdução de como funciona esse tipo de programação:

Python Orientado a Objetos

Olá a todos, hoje vou tentar *introduzir* alguns conceitos de orientação a objetos e creio que isso também me ajudará a tirar algumas dúvidas sobre essa poderosa forma de programação.

A programação orientada a objetos visa prioritariamente o reaproveitamento de código, além de deixar o código mais legivel, elegante e (claro) menor.

Tudo comeca com uma Classe. Ela serve como fábrica de objetos (calma, jájá explico o que é um objeto), e é a base da POO. Tratando isso de uma maneira mais simples, vamos imaginar que você quer criar um joguinho onde terão vários personagens.

class Personagem:
   """ Classe que cria personagens do jogo """
   def __init__(self,Nome,Poder):
       """ Método construtor da classe, onde recebe os parametros Nome e Poder de cada bonequinho """
       self.Nome = Nome
       self.Poder = Poder
       print 'Criando personagem ',Nome,' com poder ',Poder
   def Correr(self):
       print self.Nome,' está correndo!'
   def Chute(self,Adversario):
       print self.Nome,' Deu um chute em ',Adversario


Vamos agora explicar: Uma classe chamada Personagem foi criada, e para que ela fabrique algum bonequinho, precisa satisfazer os parametros do método construtor (__init__). A fabricação dele é o que chamamos de objeto ou instância de classe, e agora iremos criar um:

>>> Smurf = Personagem('Papai Smurf',30)
>>> Criando personagem Papai Smurf com poder 30

Viu? Agora temos um objeto chamado Smurf, ou seja, demos vida ao Papai Smurf e ele está pronto pra correr!

>>> Smurf.Correr()
>>> Papai Smurf está correndo!

Agora, para o chute, você deve ter visto que na definição do metodo tem um parametro Adversario, notou? Então teremos que dizer quem vamos chutar!

>>> Smurf.Chute('Gargamel')
>>> Papai Smurf Deu um chute em Gargamel

Deu pra entender como funciona? Da mesma forma que criamos o objeto Smurf, poderemos criar mais inumeros personagens usando apenas essa classe Personagem, usando esses mesmos comandos que digitei acima.

Ainda tem dúvidas não é? O que aquele self representa? O que são aquelas três aspas no inicio dos métodos e da classe? Toda classe precisa de parametros iniciais?

Vamos lá:
O self representa uma váriavel de objeto. Sem o self, quando fossem criados dois ou mais objetos as variaveis iriam sempre ser alteradas e citando como exemplo o código acima, se o ultimo bonequinho chamado 'Tux' fosse criado, todos os outros bonequinhos iam passar a chamar-se Tux também, assim como iam passar a ter o mesmo poder do Tux. Com o self, cada váriavel corresponde ao seu objeto!

As três aspas são chamadas de Doc String. Quando um programa é muito extenso, essas doc strings são de extrema necessidade para que o programador se oriente, elas documentam o código. Olha só como funciona usando o mesmo código acima:

>>> Personagem.__doc__
>>> ' Classe que cria personagens do jogo '

Sacou?

Quanto a ultima pergunta, Não. Não é preciso que toda classe receba dados iniciais, eles podem ser manipulados após a criação dos objetos apenas adicionando metodos de set. Eu poderia criar mais um método ali chamado 'RecebeNome' onde só após a criação do objeto eu iria dar nome a ele.

Bem, pretendo continuar a fazer mini-tutoriais como esse a medida que eu for tomando maior conhecimento da linguagem python. Dessa vez foi apenas um esquente, e espero que tenha ajudado alguem.






Trabalhando com strings

Só pra não deixar o blog parado, vamos dar uma pequena olhada no que o Python pode fazer com strings, apenas alguns métodos. Primeiro vale lembra que em Python, tudo são objetos, então uma string também é um objeto, e tem varios metodos embutidos que facilitam seu manuseio e formatação. Não é preciso declarar variáveis, então para criar uma string, basta atribuir:

>>> nome = 'igor'
>>> nome
'igor'

Ou para tornar um outro tipo em string:

>>> numero = 12.45
>>> string = str(numero)
>>> string
'12.45'

As strings possuem aspas simples ou duplas, para o caso de precisarmos de algumas delas dentro da própria string:

>>> nome = "meu nome é 'igor' "
>>> nome
"meu nome é 'igor' "

E se quisermos escrever uma string usando varias linhas:

>>> nome = ''' estou
... aprendendo
... python'''
>>> nome
'estou\n aprendendo\n python'

Note que um carácter quebra de linha (\n) é adicionado automaticamente com o Enter.
Agora vamos brincar com letras maiúsculas e minúsculas:

>>> nome = 'igor sobreira'
>>> nome.capitalize()
'Igor sobreira'
>>> nome
'igor sobreira'
>>> nome = nome.capitalize()
>>> nome
'Igor sobreira'

capitalize() retorna a primeira letra de string em maiúscula, mas sem alterar o valor da string atual. Tambem tem o upper(), e o lower():

>>> nome = 'igor'
>>> nome = nome.upper()
>>> nome
'IGOR'
>>> nome.lower()
'igor'

Também é possivel procurar por um caracter numa string, mostrando seu índice, mas isso retornara um erro, caso nao encontre:

>>>nome = 'python'
>>> nome.find('t')
2

Outro método muito interessante é o split():

>>> '1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']

o argumento que splt() recebe, é onde a string será cortada, e retornara uma lista como o exemplo acima.

>>> pasta = '/home/python/programa.py'
>>> pasta = pasta.split('/')
>>> pasta
['', 'home', 'python', 'programa.py']

Agora vamos fazer o inverso:

>>> '/'.join(pasta)
'/home/python/programa.py'
>>> ' ---- '.join(pasta)
'----home----python----programa.py'

Agora o método que eu acho mais interessante de todos é o replace:

>>> nome = 'mergulhando em java'
>>> nome = nome.replace(' em java', ' no python')
>>> nome
'mergulando no python'
>>> nome.replace('mergulhando em ','')
'python'

O replace pode ser utilizado pra tirar aquele estaço que fica no começo ou no final da string, mas, como não é surpresa, o Python ja tem isso pronto, é o strip(), mas ele so tira do começo e/ou do final da string:

>>> nome = ' python e muito bom '
>>> nome.strip()
'python e muito bom'

Ahh..quase ia me esquecendo, concatenar strings! Isso é algo muito dificil, creio que é a maior dificuldade de quem começa na linguagem:

>>> comeco = 'aprendendo '
>>> fim = 'python'
>>> comeco + fim
'aprendendo python'

Bem, e o print de Python, pode ser usado como o 'printf' de C:

>>> print 'aprendendo %s' %'python'
aprendendo python


É claro que existem varios outros métodos para strings, esses são os mais usados, caso alguem lembre-se de outro, pode colocar nos comentários :)

MSN feito em Python

Ja saiu a primeira versão do Emesene, um messenger feito em Python e GTK, que da suporte ao protocolo MSN. Tem uma interface bastante intuitiva, leve e é multiplataforma.

Acabei de testar e gostei muito. Ainda faltam algumas funcionalidades, como transferências de aquivos e mostrar avatar de usuário. Mas uma versão mais completa estará disponivel.

Para fazer o donwload, aqui.

Segue alguns screenshots do Emesene rodando no meu Ubuntu.


Fonte: yguarata.org

Novo Nokia N800

A Nokia lançou seu novo internet tablet, o N800, que veio para susceder o N770. Essa linha de aparelhos é voltada para conexão com a internet, não funciona como celular, ele vem com wi-fi e bluetooth, e suporta aplicações voip. Sua ótima resolução de 800 x 480 é perfeita para visualizar paginas web, tem navegador Opera, plugin de Flash 7, suporte a javascript, etc.

Vem também com webcam VGA, microfone, auto-falantes, saida para fones de ouvido, mini-USB e dois slots SD, um interno e outro externo, que suportam até 2GB cada.

Mas o mais interessante é que o N800 roda em cima de uma plataforma livre, a plataforma Maemo, que é baseada em Linux, o que permite que desenvolvedores Linux portem facilemente suas aplicações.
Mais informações: Pythonologia, Garota sem Fio.

Extraindo HTML de uma página

Aproveitando a dica anterior sobre manipulação de arquivos, vou aprensentar uma biblioteca do Python usada pra extrair o codigo HTML de uma pagina web, a urllib.

É bem parecido como a abertura de um aquivo texto, o metodo mais basico é o urlopen:


import urllib
pagina = urllib.urlopen('http://www.v2windcenter.com')
codigo = pagina.read()
pagina.close()
print codigo


Para mais informações sobre o modulo urllib.

Manipulando arquivos

Uma coisa bem interessante em Python é a manipulação de arquivos, que é bastante simples. Vamos tomar como exemplo o arquivo 'texto.txt' :

>>> f = open( '/home/igor/texto.txt', 'w')

a função open possui três argumentos: nome do arquivo, modo e buffer, sendo os dois ultimos opcionais. No exemplo acima, eu usei o nome e o modo 'w'. Vamos falar um pouco sobre os possiveis modos:

Existem três tipos basicos de modos: 'w', 'r', 'a'. Write ('w') é usado para escrever algo no arquivo, apagando o que já havia nele, e caso o arquivo ainda não exista, ele será criado. Mas e se eu quiser apenas adicionar um texto sem apagar o que ja tinha la? Ai estamos falando no modo 'a' (append, pra quem conhece os metodos de listas isso deve ser familiar), agora todo o texto escrito será adicionado no final do que tinha anteriormente (lembrando que o texto inserido é no formato string, não tem nada a ver com listas), nesse caso, se o arquivo também não existir ele será criado sem problemas. E como era de se esperar, 'r' é usado para ler um arquivo já existente.

Mas ainda tem alguns modificadores de modos:

>>> f = open('/home/igor/texto.txt','r+')

quando um '+' é inserido no final de qualquer modo, ele possibilita tanto a leitura quanto a escrita.

>>> f = open('/home/igor/texto.txt','rb')

Esse 'b', adicionado ao lado de algum modo, manuseia o arquivo em binario, e não em texto, como é o padrão.
Caso não seja especificado nenhum modo na função open, sera atribuido 'r' (read), que é o padrão.

O terceiro argumento, também opcional é o buffer, caso seja 0 ou False, não haverá buffer, ou seja, toda vez que o arquivo for ser utilizado, ele será manuseado diretamente do disco rigido; ja se for 1 ou True, então haverá buffer, o arquivo será manuseado da memoria, o que deixa o processo mais rápido. Caso for declarado um numero maior que 1, esse numero indicara o nivel de buffer (em bytes).

Mas agora vamos ao que interessa, escrever:

>>> f = open('/home/igor/Python/texto','w')
>>> f.write('Ola Mundo!')

Como o modo padrão é texto, não é necessário a extensão .txt. Não podemos esquecer de fechar o arquivo:

>>> f.close()

Existem várias maneiras de ler o que está escrito, a basica é read()

>>> f = open('/home/igor/Python/texto', 'r')
>>> ler = f.read()
>>> f.close()
>>> print ler
Ola Mundo!

O metodo read() usado sem nenhum argumento, mostrará tudo que esta no aquivo, mas se quisermos ler apenas os tres primeiros caracters (bytes), podemos usar da seguinte maneira:

>>> f = open('/home/igor/Python/texto') #lembrando que o modo 'r' pode ser excluido pois e o padrao
>>> ler = f.read(3)
>>> print ler
Ola

Aqui apenas especificamos que so serão lidos os tres primeiros caracters (bytes), e caso queira ler o restante, o read() começará de onde parou

>>> restante = f.read()
>>> print restante
Mundo!

Agora vamos adicionar mais alguma coisa no nosso arquivo:

>>> f = open('/home/igor/Python/texto','a')
>>> f.write('\nOla Python')
>>> f.close()

Aqui usamos o 'a' (append), pra adicionar sem apagar o que ja havia no arquivo, e o '\n' é usado pra pular uma linha, lembrando que tudo é string. Agora vamos ver o resultado de outras maneiras:

>>> f = file('/home/igor/Python/texto', 'r')
>>> linha1 = f.readline()
>>> linha2 = f.readline()
>>> f.close()
>>> print linha1
Ola Mundo!

>>> print linha2
Ola Python

O readline() sem argumento, ira ler todo o conteudo de uma linha, porem é possivel dar um limite de caracters, assim como o read. linha1 guarda o conteudo da primeira linha, quando eu chamamos o readline() mais uma vez, ele vai começar a ler de onde tinha parado, ou seja, na segunda linha. Caso não tenha percebido, ao inves de open, usamos file, que da o mesmo resultado.

Pra quem é fã de lista (como eu), não poderia faltar um metodo que retornasse todo o conteudo do arquivo numa lista, e como tudo em Python, ele ja está pronto! É o readlines():

>>> f = open('/home/igor/Python/texto', 'r')
>>> ler = f.readlines()
>>> f.close()
>>> print ler
['Ola Mundo!\n', 'Ola Python']

Cada linha fica em um indice da lista, no formato de uma string.

Para verificar se o arquivo foi realmente fechado, basta digitar:

>>> f.closed
True

Bem...espero ter esclarecido um pouco sobre manipulação de arquivos em Python, alguma duvida, complementação ou correção, podem comentar ou mandar um email.

Primeiro post

Bem, nesse primeiro post, gostaria de dizer o que tenho em mente ao criar este blog. Basicamente pretendo colocar dicas sobre a linguagem de programação Python, tenho muito pouca experiência com programação, então como estou aprendendo Python, tudo que eu for aprendendo e achando interessante na linguagem, vou escrever um pouco, dando dicas.

Desse modo posso compartilhar o que vou aprendendo e principalmente, alguem que esteja lendo e tenha alguma dica a mais, alguma atualização, correção, poderá deixar nos comentarios, ou me mandar um texto completo para ser publicado (igor@v2windcenter.com), afinal a principal meta desse blog é essa, a troca de informações.

Como Python, assim como qualquer linguagem de programação, estão totalmente ligadas com tecnologia, também pretendo falar um pouco sobre novidades tecnológicas que venham a surgir.

Espero ajudar um pouco quem estiver começando no Python, assim como eu, e também receber algumas dicas, pois o principal objetivo desse blog é o aprendizado. :)