Novo endereço do blog janeiro 8, 2010
Posted by Rafael Pinheiro in Python.Tags: blog, novo
add a comment
Novo endereço do blog: http://rbpinheiro.wordpress.com/
Enviando e-mail com python pelo gmail fevereiro 22, 2009
Posted by Rafael Pinheiro in Python.add a comment
Enviar email utilizando python é uma tarefa bem simples, usamos a biblioteca smtplib que já vem na instalação padrão e assim não precisamos de nehuma dependência externa.
Exemplo de envio de um email simples:
import smtplib
smtp = smtplib.SMTP('mail.server.com') #substitua pelo servidor smtp desejado
smtp.sendmail('seu.email@server.com',
'destinatario@server.com',
'''To: destinatario@server.com
From: seu.email@server.com
Subject: Assunto aqui
Aqui vai o corpo da mensagem''')
smtp.quit()
É necessário cuidar para que o cabeçalho do e-mail esteja formatado corretamente, existe um padrão a seguir:
To: destinatario@server.com From: seu.email@server.com Subject: Assunto aqui Aqui vai o corpo da mensagem
Mas se você testar esse código com o gmail não vai funcionar, precisamos enviar de forma segura, e para isso usamos o protocolo tls.
A maneira mais simples é utilizar uma biblioteca externa chamada libgmail.
Mas se você quiser que o seu programa rode sem depender dela, não é tão complicado assim, só temos que adicionar algumas linhas ao código:
import smtplib
smtp = smtplib.SMTP('smtp.gmail.com')
#ativando o ssl
smtp.ehlo() #inicia a troca de dados om o servidor
smtp.starttls() #ativa o tls
smtp.ehlo() #reinicia a troca de dados
smtp.login('seu.email@gmail.com', 'sua_senha') #não preciso explicar esse =P
smtp.sendmail('seu.email@server.com',
'destinatario@server.com',
'''To: destinatario@server.com
From: seu.email@server.com
Subject: Assunto aqui
Aqui vai o corpo da mensagem''')
smtp.quit()
Por enquanto é isso, apenas o envio de um email simples.
Automatizando tarefas com AutoIt – pt2 janeiro 7, 2009
Posted by Rafael Pinheiro in Uncategorized.Tags: autoit, automatiza, automatizar instalação, bloco de notas, ControlClick, instalaçao, send, windows, WinWaitActive
2 comments
No post anterior mostrei como abrir o bloco de notas e digitar algo utilizando a linguagem autoit.
Acabamos com esse código:
Run("notepad.exe")
WinWaitActive("Sem título - Bloco de notas")
Send("Escrevendo no bloco de notas")
Como prometi no outro post vou mostrar como fechar o bloco de notas, para isso vamos aprender a simular cliques. Isso é bem importante caso queira, mais tarde, automatizar instalações.
A primeira coisa que devemos nos preocupar no caso do bloco de notas é dar tempo suficiente para que o texto escrito seja lido, vamos utilizar o comando Sleep para fazer o script dormir por um tempo:
Sleep(2000)
Adicionando esta linha fazemos o programa dormir por 2 segundos, o valor passado é em milésimos(1000 = 1 segundo). Utilize um valor que seja suficiente para o texto que você escrever.
Agora sim podemos utilizar o comando para fechar a janela:
WinClose("Sem título - Bloco de notas")
O comando WinClose recebe o título da janela da mesma forma que o WinWaitActive, mas agora estamos fechando a janela.
Se você executar o script agora verá que temos um problema, o bloco de notas pergunta ao usuário se ele deseja salvar o documento antes de fechar.
Agora vou mostrar como simular cliques para responder ao bloco de notas. Vamos utilizar o AutoIt Window Info novamente, dessa vez precisamos do título daquela janelinha que abre perguntando se queremos salvar.
Siga os passos do post anterior, não se esquecendo de selecionar a janela certa e travando os valores no Window Info.
Precisamos esperar essa janela ficar ativa. Utilizamos o comando WinWaitActive mais uma vez, mas passamos o título da janela que pegamos agora:
WinWaitActive("Bloco de notas")
Bom, agora que já estamos com a janela que precisamos ativa, vamos clicar no “Não”:
ControlClick("Bloco de notas", "&Não", 7)
Utilizamos o comando ControlClick e passamos 3 argumentos que vou explicar agora.
Primeiro passamos a janela em que o controle(botão) está, depois o texto do botão. Você deve estar estranhando o “&” antes do texto, ele é utilizado para criar atalhos do teclado. Embora o “&” não apareça para nós, ele está lá e precisamos passar ele junto com o texto. Mais uma vez o Window Info nos ajuda nisso:

Informações do botão
Com a aba Control(1) selecionada no Window Info, clicamos na janela do bloco de notas que está perguntando se queremos salvar e posicionamos o cursor no botão que queremos pressionar, o “Não” nesse caso, e então travamos os valores no Window Info(Ctrl + Alt + F).
Agora podemos copiar o texto no campo Text(2) dando um clique duplo.
O terceiro argumento que passamos é o ID(3) do botão que também pode ser pego no Window Info.
Agora o nosso script clica no botão para não salvar as alterações e o bloco de notas fecha.
Essa é a principal ferramenta para quando formos automatizar instaladores.
Exste uma maneira mais simples de responder “Não” ao bloco de notas, mas queria mostrar como clicar no botão.
Agora vou mostrar a outra maneira, utilizando atalhos do teclado. Antes disse que o “&” representava o atalho, então na verdade o atalho seria Alt + a letra que o “&” está antes, ou seja, Alt + N. Para simular o teclado utilizamos o Send, e o Alt temos que substituir por “!” no AutoIt:
Send("!n")
É bem mais simples utilizar o atalho com o Send, mas nem sempre é possível. Vale a pena saber as duas técnicas e utilizar a mais apropriada para cada situação.
Automatizando uma instalação no próximo post.
Automatizando tarefas com AutoIt janeiro 6, 2009
Posted by Rafael Pinheiro in Uncategorized.Tags: autoit, automatizar, automatizar instalação, instalaçao, tarefa, tarefas, windows
3 comments
AutoIt é uma linguagem de script que permite automatizar tarefas no Windows. Com uma sintaxe parecida com Basic é possível rodar programas, simular cliques e digitação, etc.
É bem útil para automatizar instalações ou tarefas repetitivas.
Agora uma introdução, é necessário baixar o interpretador aqui.
Recomendo baixar a versão Full, pois vem com uns aplicativos extras que nos ajudarão.
Vou começar mostrando como abrir o bloco de notas e digitar algo nele “automagicamente”:
Primeiro vamos criar um novo script, após a instalação clique com o direito onde deseja criar o script e você deve ter a seguinte opção:

Novo Script
Após criar o arquivo vamos editá-lo com a opção “Edit Script” no menu do botão direito. O script abre no editor scite, e contém alguns comentários de documentação, eu vou tirar esses documentários, mas se deixar eles lá não fará nenhuma diferença no programa.
O primeiro comando que usaremos é o Run, ele roda o programa que passarmos como string:
Run("notepad.exe")
notepad.exe é o nome do arquivo do bloco de notas, ele fica na pasta do windows.
Agora vamos fazer o script dormir até que o bloco de notas esteja aberto e pronto para ser utilizado:
WinWaitActive("Sem título - Bloco de notas")
Utilizamos o comando WinWaitActive para esperar pela janela, e passamos o título da janela que queremos esperar.
Para evitar erros e também porque é chato ficar digitando o nome da janela, vamos usar o programa AutoIt Window Info que está na pasta do autoit no menu iniciar.

AutoIt Window Info
Certifique-se que a aba “Window” está selecionada, o título da janela fica na propriedade “Title”. Abra o bloco de notas e clique uma vez em “Title” para selecionar e depois clique duas vezes para copiar valor. Agora é só colar no seu script e colocar as aspas.
Se o valor do Title mudar quando você copiar é porque o mouse está passando por cima de outra janela, posicione as janelas para que isso não ocorra ou use o atalho Ctrl + Alt + F para travar os valores.
Agora já podemos escrever o que quisermos no bloco de notas:
Send("Escrevendo no bloco de notas")
Para utilzar elementos como ponto de exclamação devemos colocá-los entre chaves, “{!}”. E para quebrar a linha “{ENTER}”.
Agora o script está pronto, salve e execute.
O script ainda necessita que o autoit esteja instalado para ser executado. Se quiser distribuir o seu script clique com o drieito nele e na opção “Compile Script”.
O script também pode ser compilado abrindo o programa Compile Script to .exe na pasta do menu iniciar do autoit. Por esse método é possível mudar o ícone e definir o nível de compressão para diminuir o tamanho do arquivo final.
Por enquanto nosso script está assim:
Run("notepad.exe")
WinWaitActive("Sem título - Bloco de notas")
Send("Escrevendo no bloco de notas")
No próximo post sobre AutoIt vou continuar esse script mostrando como simular cliques e fechar janelas, mas por enquanto já dá pra assustar alguém fazendo o bloco de notas escrever sozinho =P
for, while (estruturas de repetição) janeiro 6, 2009
Posted by Rafael Pinheiro in Python.Tags: for, Python, range, repetição, while
add a comment
Nesse post vou falar sobre as estruturas de repetição em python, normalmente utilizamos estas quando precisamos passar pelos valores de uma lista, tupla ou dicionário.
For
O for é muito simples, pensando de acordo com o padrão: “para item em lista” ou “para cada item em lista”. Então se tivéssemos uma lista de nomes em uma variável chamada nomes ficaria assim: “para nome em nomes”.
Note que o nome que utilizamos depois do para é uma variável, e escolhemos o nome dessa variável quando digitamos o for, então funcionaria do mesmo modo se tivessemos feito: “para pessoa em nomes”.
Agora imaginando que temos uma lista de strings vou mostrar como imprimir cada string na tela:
>>> lista = ('isso', 'é', 'uma', 'lista')
>>> for item in lista:
print item
isso
é
uma
lista
Uma função bastante utilizada em conjunto com o for é a função range. Essa função retorna uma lista numérica do tamanho do número que você passar como atributo, começando do zero:
>>> range(15) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] >>> for i in range(5): print i 0 1 2 3 4
Também é possível passar dois número, assim definimos de onde a lista deve começar:
>>> range(5, 10) [5, 6, 7, 8, 9] >>> for i in range(5, 10): print i 5 6 7 8 9
while
O while é uma estrutura de repetição, assim como o for, mas a repetição se dá a partir de um teste lógico, assim como um if. Vou explicar, a repetição ocorre enquanto o resultado de um teste for verdadeiro, por exemplo:
>>> i = 0 >>> while i<5: print i i = i + 1 0 1 2 3 4
Listas, tuplas, e dicionários dezembro 30, 2008
Posted by Rafael Pinheiro in Python.Tags: básico, Python
add a comment
Vou mostrar mais alguns tipos, esse tipos permitem armazenar mais de um valor na mesma variável.
Lista
>>> lista = [5, "minha lista", 5.6]
Os itens das listas ficam entre “[" e "]” e são separados por vírgulas. Os itens da lista podem ser de váios tipos diferentes e para chamá-los usamos o seu ńdice dentro da lista, começando por zero:
>>> lista[0] 5 >>> lista[1] 'minha lista' >>> lista[-2] 'minha lista'
Também é possível usar índices negativos para índice começando no final da lista e indo em direção ao início. É possível modificar os elementos de uma lista indicando o índice:
>>> lista[2] = 'outra string'
Para pegar sub-listas utilizamos “:”(dois pontos):
>>> lista[0:2] [5, 'minha lista'] >>> lista[:2] [5, 'minha lista'] >>> lista[1:] ['minha lista', 'outra string']
O número antes do dois pontos indica o índice inicial da sub-lista e o que fica depois indica quantos itens iremos pegar. Caso não se coloque nenhum número antes dos dois pontos, a nova lista irá começar do início da antiga, e se não colocarmos nada após os dois pontos, a nova lista irá até o fim da antiga.
As listas têm alguns métodos:
append – adiciona um novo elemento na lista.
>>> lista = [ 5, 15, 6, 4, 0 ] >>> lista.append(3) >>> lista [5, 15, 6, 4, 0, 3]
sort – ordena a lista
>>> lista.sort() >>> lista [0, 3, 4, 5, 6, 15]
count – conta as ocorrências do parâmetro em uma lista
>>> lista.count(0) 1
reverse – inverte a ordem dos itens da lista
>>> lista.reverse() >>> lista [15, 6, 5, 4, 3, 0]
pop – remove o item pelo índice
>>> lista.pop(0) 15 >>> lista [6, 5, 4, 3, 0]
remove – remove o item que foi passado
>>> lista.remove(0) >>> lista [6, 5, 4, 3]
Tupla
>>> tupla = ( 1, 5, "texto" )
A tupla é parecida com a lista, mas usamos “(” e “)” para deinir a tupla e ela é imutáel, ou seja, não podemos alterar seu valor, ou usar os métodos descritos anteriormente.
>>> tupla[2] 'texto' >>> tupla[:2] (1, 5)
Para chamar um valor que está na tupla usamos os índices da mesma maneira que a lista.
Dicionário
>>> dic = {'primeiro':5,
... 15:"string"}
>>> dic
{15: 'string', 'primeiro': 5}
No dicionário utilizamos “{” e “}” para definir os itens e os índices são definidos pelo usuário, usamos a sintaxe “índice : valor” para definir um item.
>>> dic['primeiro'] 5 >>> dic[15] 'string'
Segue a mesma lógica para chamar os valores, passando o índice entre colchetes.
Alguns métodos:
keys – retorna os indices existentes
>>> dic.keys() [15, 'primeiro']
values – retorna os valores existentes
>>> dic.values() ['string', 5]
pop – remove o item pelo índice
>>> dic.pop('primeiro')
5
>>> dic
{15: 'string'}
if (estrutura de decisão) dezembro 24, 2008
Posted by Rafael Pinheiro in Python.Tags: decisão, estrutura, if, Python
add a comment
Nesse post vou abordar estruturas de decisão em python. Essas são estruturas básicas e é impossível criar um programa “decente” se usá-las. Para quem vem de outra linguagem é interessante observar que o python não utiliza chaves ou algo do tipo para delimitar blocos, mas indentação. E para quem está começando agora no mundo da programação, é importante entender o conceito de indentação:
Indentação serve para organizar o código-fonte de maneira hierárquica para melhor visualização. Pelo menos na maioria das linguagens, em python a indentação também serve para delimitar blocos, ou seja, definir o que pertence a qual bloco. Exemplo:
bloco 1
pertence ao bloco 1
também pertence ao bloco 1
não pertence ao bloco 1
Para saber mais sobre indentação clique nesse link.
Estrutura de decisão
if x > 0: x = -1
O exemplo acima mostra uma estrutura de decisão básica em python. O “if” é traduzido como “se”, sendo assim: se x maior que 0. Compreendendo isso fica fácil entender a estrutura de decisão, basicamente testamos se uma condição é verdadeira,nesse caso se x > 0. Finalizamos o teste com “:”, o que estiver no próximo nível de indentação será executado caso xseja maior que 0.
Os testes executados sempre retornam um valor booleano, então são verdadeiros(True) ou falsos(Fasle).
Também podemos fazer algo caso o resultado seja falso:
if x>0:
x = -1
else:
x = +1
O comando que está abaixo do if vai ser executado caso o resultado do teste seja verdadeiro, senão(else) o que está abaixo do else será executado.
Muitas vezes precisamos fazer mais de um teste, caso o primeiro teste dê negativo fazemos outro teste:
if x>0:
x = -1
elif x == 0:
x = 1
else:
x = +1
Agora usamos o elif(else + if) para faze outro teste antes do else, que só será executado se todos os testes falharem. No elif usamos dois sinais de igual para comparar, isso porque um sinal de igual serve para atribuição(dar valor à variável) e dois servem para comparar.
Utilizamos “==” para verificar igualdade, “>” ou “<” para verificar qual o maior ou menor, “>=” ou “<=” para verificar se é maior/menor ou igual e ainda podemos verificar o contrário de todos esses adicionando um “!”.Exemplo:
if x != 5:
Testa se x é diferente de 5. Ou ainda adicionando um “not”:
if not x == 5:
interface básica dezembro 22, 2008
Posted by Rafael Pinheiro in Python.Tags: dialogs, Python, Tkinter, tksimpledialog
add a comment
Nesse post não vou ensinar como fazer interface gráfica no python, mas simplesmente como abrir dialogs para não dependermos da linha de comando.
Dialogs são aquelas janelinhas de informação ou erro que abrem como pop-ups.
Usaremos a interface gráfica padrão do python para isso, o Tkinter
A primeira coisa a se fazer é importar essa biblioteca, usamos o comando import:
import Tkinter
Agora vamos importar mais duas bibliotecas para fazer o dialog. A biblioteca tkMessageBox para mensagens e a tkSimpleDialog para os inputs:
import tkMessageBox import tkSimpleDialog
O código a seguir serve para iniciar a interface gráfica, não vou me apofundar muito pois não é o objetivo. Se quiser saber mais sobre Tkinter existe um tutorial aqui.
root = Tkinter.Tk()
Esse próximo comando é opcional, quando inicializamos a interface gráfica é criada uma janela por padrão. Se quisermos esconder essa janela que não vamos utilizar basta essa linha:
root.withdraw()
Agora podemos começar a lógica do nosso programa, que está no post anterior.
nome = tkSimpleDialog.askstring('Nome', 'Qual o seu nome?')
Aqui substituímos o raw_input pelo tkSimpleDialog, observe que usamos tkSimpleDialog.askstring, o askstring indica o tipo que queremos receber, ask significa perguntar em inglês, então: perguntar string. As opções são: askstring, askfloat, askinteger e outras opções mais avançadas para arquivos, cores, etc.
Novamente passamos parâmetros entre parênteses, o primeiro é o título da janela e o segundo a pergunta.

askstring no Gnome(Linux)
Agora que já recebemos o nome, temos que dar que dar um oi:
tkMessageBox.showinfo("Nome", "Oi " + nome)
Mantendo a mesma ordem dos parâmetros(título, mensagem) usamos a opção showinfo do tkMessageBox. Novamente temos outras opçoes além de showinfo: showwarning, showerror e outras.
Os nomes dos comandos fazem sentido se você tiver um conhecimento básico de inglês, isso pode facilitar bastante o aprendizado.
Assim concluímos o nosso programa, mas devemos seguir mais alguns passos para que ele rode sem apresentar erros, utilizando as duas primeiras linhas do arquivo que servem para configurações especiais:
Para evitar erros é bom declara a codificação do nosso programa, por razões de compatibilidade com vários idiomas e sistemas operacionais recomendo usar utf-8(unicode), para saber mais sobre isso olhe na wikipédia.A declaração é feita através da seguinte linha adicionada na primeira ou segunda linha do arquivo:
# -*- encoding: utf-8 -*-
Usuários Linux ainda tem que adicionar mais uma linha para poder executar clicando diretamente no ícone(sem precisar do terminal), essa linha indica que deve ser aberto com o interpretador do python:
#!/usr/bin/env python
Agora nosso programa está completo, eis o código:
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import Tkinter
import tkMessageBox
import tkSimpleDialog
root = Tkinter.Tk()
root.withdraw()
nome = tkSimpleDialog.askstring('Nome','Qual o seu nome?')
tkMessageBox.showinfo("Nome", "Oi " + nome)
Salvem em um arquivo, no linux a extensão não é importante. Mas no windows devemos salvar como .pyw, antes estávamos salvando como .py.
A exensão .pyw impede que o python abra o shell(linha de comando), assim sua aplicação é inteiramente gráfica.
No linux você deve dar permissão de execução e quando der dois cliques vai ter as opções para executar com terminal, sem terminal e ver o código-fonte:

No windows os dois cliques vão executar o programa abrindo ou não o terminal de acordo com a extensão.
Programa com input dezembro 20, 2008
Posted by Rafael Pinheiro in Python.Tags: input, Python, raw_input
add a comment
Vou mostrar como fazer um programa que recebe um valor do usuário, chamamos isso de input do usuário.
nome = raw_input("Qual o seu nome?")
Temos duas formas de pegar o input do usuário na linha de comando, o comando input e o raw_input.
Os dois comando possuem um retorno, ou seja, eles retornam um valor para o programa.
O comando raw_input retorna sempre um valor do tipo string. O input é um pouco diferente, ele define o tipo de acordo como valor, se o usuário digitar um número inteiro será do tipo int, se digitar letras será do tipo string, etc.
O retorno do comando nós armazenamos na variável “nome” para usarmos depois.
Perceba que usamos parenteses após o comando, é dentro desses parênteses que passamos valores para o comando, no caso do input e raw_input passamos uma string que é o que ele deve peguntar.
Agora que temos o input do usuário armazenado em uma variável podemos dar um oi para ele.
print 'Oi', nome
Desse modo estamos dizendo ao python para imprimir na tela a string ‘Oi’ e a string nome separadas por um espaço. Mas temos outras formas de fazer isso:
print 'Oi ' + nome
Aqui usamos a concatenação de strings, basicamente “colamos” uma string na outra. Em outro post mostro uma forma mais avançada de fazer isso.
Então nosso programa ficou assim:
nome = raw_input("Qual o seu nome? ")
print 'Oi', nome
Salve em um arquivo .py e execute pela linha de comando ou execute os comandos no shell interativo do python.
Muitas pessoas não gostam da linha de comando, e é um grande incentivo ver o seu programa rodando em modo gráfico, então no próximo post vou mostrar como fazer esse mesmo programa usando janelas.
tipos e variáveis dezembro 20, 2008
Posted by Rafael Pinheiro in Python.Tags: Python, tipos, variáveis
add a comment
Na programação usamos variáveis para guardar valores, mas temos que seguir algumas regras quando formos dar o nome à nossa variável:
Diferente das variáveis matemáticas, podemos usar mais de uma letra e até números no nome da nossa variável.
O nome das variáveis devem começar com uma letra e não podem conter espaços.
O python é case-sensitive, então ele diferencia maiúscula de minúscula. Var é diferente de var.
Para criarmos a variável basta atribuirmos um valor a ela usando o sinal “=”. Exemplo:
var = 7
A variável “var” contem o valor 7, então ela é do tipo inteiro, ou seja, ela armazena números inteiros.
Os principais tipos são:
Inteiro
Tipo numérico para inteiros, chamado integer(inteiro em inglês) e abreviado para int.
Exemplo:
num = 55
Ponto Flutuante
Tipo numérico para números com ponto flutuante(número com vírgula), chamado de float.Utiliza-se o ponto para casas decimais, e nunca a vírgula.
Exemplo:
num = 55.6
Booleano
Tipo numérico que armazena apenas 1 ou 0, onde o 1 significa verdadeiro e o 0 falso. Normalmente atribuímos “True” no lugar de 1 e “False” no lugar de 0. Chamado no python de boolean.
Exemplo:
flag = True
String
Tipo para armazenar texto. O texto a ser armazenado fica entre aspas simples ou duplas.
Exemplos:
var = 'Isso é uma string' var2 = "e isso também"