Philss

Fevereiro 26, 2008

O clássico “Hello World!”

Arquivado em: Introdução — Etiquetas HTML:, , , , , — Philip Sampaio @ 11:20 pm

Programadores, no passado, tinham o costume de criar o primeiro programa em uma linguagem de programação em estudo que mostrasse de alguma forma a frase “Hello World”(em português: “Olá mundo”). Hoje em dia, pelo menos no meu curso técnico de informática, quebraram este ritual.
Não pretendo cometer esta desonra.

Pois bem, let’s go!

Vou mostrar a construção da interface no Glade, apesar de ser um exemplo simples que podia ser feito via código(com pyGTK direto)…
Antes de prosseguir, leia este site: http://www.cin.ufpe.br/~cinlug/wiki/index.php/Mantendo_A_Sanidade_Com_O_Glade

Abra um novo projeto no Glade e crie um novo widget do tipo janela(window).
glade0011.jpg

Depois crie um Vertical Box com 2 “itens”(clique no botão e em seguida clique na interface).

glade002.jpg

Em seguida crie um Horizontal Box no primeiro item do Vertical Box. Para fazer isso, basta clicar no ícone ao lado esquerdo do Vertical box e em seguida clicar na parte superior do Vbox existente. Escolha 2 itens novamente(mas agora é em horizontal).

Feito isso, crie um “Text Entry”(conhecido como edit em algumas GUIs), um “Button”(botão) e um “Label”(etiqueta de texto) desta forma:glade0031.jpg

OBS.: Eu redimensionei a interface utilizando as bordas do widget window1.

Agora chegou a hora de dar nomes ao widgets..
Clique em cada um e dê os seguintes nomes(claro que você pode definir isto sozinho!):
Ao text entry: entnome;
ao botão: btnok
e ao label: lblresposta.
No label, ative a opção “Usar marcação”, debaixo do rótulo.

glade005.jpg
Salve o projeto em algum diretório(dãr! lógico, né? Na memória vai ficar difícil) .

Agora vem uma parte muito importante!
Definir as ligações entre a interface e o código.. Isso se faz na aba “Signals”(Sinais).
Teremos que ligar o sinal de quando o usuário clicar no botão ok, e de quando o programa for “destruído”(quando clicarmos no fechar da janela).

Definindo o sinal do botão:
glade004.jpg

Não se esqueça de dar um “Enter” para salvar a informação.
Faça o mesmo com o widget “window1″(ficou com o nome padrão mesmo :)), só que em vez de conectar ao evento “Clicked”, conecte com o evento “Destroy” que está em GtkObject(aproveite pra fuçar outros eventos, você vai encontrar eventos diferentes em alguns widgets). Deixe o padrão mesmo: on_window1_destroy.
Agora salve o projeto e feche-o se quiser.

O código

Agora vem a parte interessante.. o código!
Vou sugerir que você sabe o básico(bem básico!) de Python pois postarei o código auto-explicado, com comentários.

Hello_world.py(somente para identificar o código/script):

#!/usr/bin/python
#-*- encoding: utf8 -*-
#Arquivo: Hello_World.py

"""Primeira linha pode ser desnecessária na maioria das ocasiões,
mas diz a algum programa que queira abrir este script/documento, onde está
o interpretador"
""
"""Segunda linha diz ao interpretador para aceitar caracteres como acentos e cedilhas.
É opcional também, mas sem isso você não poderá usar acentos nos comentários"
""

import gtk, gtk.glade
#importa a biblioteca gtk e gtk.glade
import pygtk
#mesma coisa, importa o wrapper pygtk, para que possamos editar os widgets da interface
#podemos até criar toda a interface com o pygtk, mas é muito trabalhoso
pygtk.require("2.0")
#Versão mínima requerida para o código

class Hello_World():
    def __init__(self):
        """Função inicial, carrega a interface e conecta os sinais dos widgets"""
        interface           = gtk.glade.XML("hello_world.glade")
        self.janela         = interface.get_widget("window1")
        self.entnome        = interface.get_widget("entnome")
        self.lblresposta    = interface.get_widget("lblresposta")
        #Define as variáveis dos objetos que utilizaremos.
        #Neste caso são todos, exceto o botão
       
        dic = { "on_btnok_clicked"        : (self.on_btnok_clicked),
                "on_window1_destroy"    : (self.on_window1_destroy)
                }
        #Cria o dicionário com os sinais conectados aos callbacks
       
        interface.signal_autoconnect(dic)
        #Faz a conexão dos sinais com os callbacks
        self.janela.show_all()
        #Exibe a janela
       
        gtk.main()
        #inicia o loop GTK, e faz rodar a interface em loop
        #veja como isto funciona no tutorial "Mantendo a sanidade com o Glade"
        #cujo link postarei no final do tutorial
       
    def on_btnok_clicked(self,botao):
        """Função para quando o botão OK for clicado"""
        nome = self.entnome.get_text()
        #Pega o texto do text entry
        self.lblresposta.set_markup("<big>Hello World!</big> Este programa foi criado por "+nome)
        #Dá a resposta no label. Poderia ser usado o set_text, mas neste caso estamos usando marcação XML no exemplo
       
    def on_window1_destroy(self,janela):
        """Fecha o programa interrompendo o loop GTK"""
        gtk.main_quit()
if __name__ == "__main__":
    Hello_World()
    #roda o programa
 

————————-
Obs: Tive que trocar algumas aspas simples por duplas, mas acho que não há problema aqui.
Com os comentários o programa ficou grande, mas sem eles foram apenas 23 linhas essenciais!
Pouquíssimo código!

Para rodar o programa, digite em um terminal:
$python /caminho/do/script/Hello_World.py
OBS.: O caracter “$” não é para digitar. Ele significa que você está como usuário normal no sistema.

Você também pode rodar diretamente com o SPE ou Eric(os outros IDEs eu não sei), clicando em “Run/Stop”(no SPE).

Programa funcionando:
programa001.jpg

Fiz algumas modificações, como a largura da borda do “window1″(Para isso, vá em Propriedades > Common > Largura da borda: 10 ) e o redimensionamento da janela (Em Propriedades > General > Redimensionável: Não).

Por hora é só. Um programa bem simples, mas deu pra ter uma noção de como a “coisa” funciona.
Por favor, não deixe de postar dúvidas e críticas.

SPE: Um IDE para Python

Arquivado em: Introdução — Etiquetas HTML:, , , , — Philip Sampaio @ 2:33 pm

O Stani’s Python Editor (SPE) é um editor de códigos muito prático e funcional. Ele possui uma interface muito legal e de fácil compreensão.

Possui UML, PyChecker, Debugger,auto-indentação e algumas outras coisas.

Gosto dele pois é simples como a linguagem Python, mas igualmente poderoso. Na verdade o poder está nas mãos do programador e não da IDE que ele utiliza(oque quis dizer foi que o editor não deixa o programador na mão ;) ) .

A visualização do código é muito fácil com ele. Eis um ScreenShot:

Um IDE para Python

Site do projeto: http://pythonide.stani.be/

O Construtor de interfaces Glade

Arquivado em: Introdução — Etiquetas HTML:, , , , — Philip Sampaio @ 12:51 am

Muitos de vocês, leitores, devem estar acostumados ao modo de desenvolvimento do Windows (VB/Delphi), oque me faz pensar que vocês odiariam ter que desenvolver uma interface gráfica somente em códigos. Pois bem, existem muitos programas que utilizam este método para construir interfaces: somente em código fonte.

Isso pode ser muito bom, devido ao controle sobre o código-fonte, já que foi tudo construído por você mesmo, programador.

Mas, como nem todo mundo tem paciência e disposição suficiente para construir interfaces gráficas via código, a maior parte das interfaces que serão criadas nos tutorias, serão feitas com o Glade.

Mas o que é o Glade?

O Glade é um programa para desenvolvimento de interfaces gráficas para GTK+(The Gimp Toolkit).

Com ele, é possível criar interfaces independentes de códigos, para que possa haver uma separação de códigos e interface. Isso beneficia muito o programador(ou programadores envolvidos no mesmo projeto), já que é muito mais fácil corrigir erros modificando só uma área do programa- interface ou código-fonte. Além disso, não acostuma o programador a mexer nas duas coisas ao mesmo tempo- estética e funcionalidade(design e código).

Acho que um programador não é obrigado a saber desenhar interfaces de usuários, já que o trabalho dele é programar, e não desenhar(desenhar é só um modo de falar, o programador é obrigado a saber várias coisas sobre acessibilidade, cores e etc).
Com o Glade(ou outro GUI deste tipo), o trabalho pode ser muito bem dividido, aumentando a produtividade!

Imagens do software

Tela principal do Glade

Está é a interface do Glade 3.
Do lado esquerdo temos a palheta de widgets(é como se chamam os objetos da interface), a direita temos a treeview dos widgets já criados, e abaixo disso temos as propriedades dos widgets.

Glade em ação.

Um exemplo funcional.

Explicarei mais afundo algumas coisas sobre o Glade, mas basicamente construirei interfaces nele e modificarei em pyGTK.

Fevereiro 25, 2008

IDEs para Python

Arquivado em: Introdução — Etiquetas HTML:, , , , — Philip Sampaio @ 4:13 pm

Essa pagina é uma lista de IDEs para desenvolvimento em Python com uma pequena descrição das mesmas para que as pessoas possam decidir qual delas se adapta melhor aos seus requisitos. Essa listagem surgiu a partir de uma discussão ocorrida na lista python-brasil. O autor de opiniões pessoais é colocado entre parêntesis.

IDEs são ambientes integrados para desenvolvimento de software.

Atualmente eu uso o SPE, pois este atende todas as minhas necessidades além de ser muito estável e de fácil entendimento(Philip Sampaio).

 

Livres

Idle - http://www.python.org - O IDLE vem com o Python. É feito com Tkinter e se você se acostumar pode lhe ajudar bastante. É bem simples de ser usado também.

SPE - http://pythonide.blogspot.com/ - Desenvolvido com wxPython é livre e tem algumas funcionalidades interessantes. Tem wxGlade como plugin para desenho de telas gráficas.

Pida - http://pida.berlios.de/ - É uma IDE desenvolvida com PyGTK e visa a integração com o Vim. Oferece recursos como project management, source code management, code browser, code refactor, profiler, debugger entre outros.

Eric4 - http://www.die-offenbachs.de/eric/index.html - Dos IDEs esse é o que mais gosto. Não é exatamente o que eu uso (OsvaldoSantanaNeto) mas acho que é o mais completo de todos. É feito com a biblioteca QT e se integra às ferramentas da QT e com outros softwares como o Bicycle Repair Man (refactoring) e TabNanny (verificação de indentações). O autor dos bindings python para o Qt4, lançou um instalador para windows que contém as bibliotecas e os programas de desenvolvimento do Qt4, o pyqwt e o Eric4, o que facilita bastante a instalação no windows. Segue o link para o instalador: http://www.riverbankcomputing.com/Downloads/PyQt4/GPL/.

Boa-Constructor - http://boa-constructor.sf.net - Essa é a “única” IDE ao estilo RAD do Delphi/VB. Funciona com o wxPython na versão 2.4 e é acho que é a mais fácil de ser usada apesar de não promover boas práticas de desenvolvimento como a de separar lógica de negócios de apresentação (telas). As outras IDEs não possuem mecanismos para desenho de telas gráficas mas podem usar ferramentas como Glade e/ou wxGlade.

Eclipse - http://www.eclipse.org - Diferente de todos os outros. Pesado, grande, monstruoso mas muito poderoso. É feito em Java e é ideal para desenvolvimento Java. Mas existem plugins para se desenvolver em Python com ele (e detalhe: atualmente é um brasileiro quem o mantém) que é o ppydev: http://pydev.sourceforge.net/

EasyEclipse - http://www.easyeclipse.org/site/distributions/python.html

DrPython - http://drpython.sourceforge.net/ - usa wxPython. Criado para ser utilizado em escolas.

IPython - http://ipython.scipy.org/ - Um shell com muitos recursos, através das comandos “mágicos”. Bastante útil, modo texto apenas. Você pode usa-lo como um shell “acoplado” aos seus programas também.

KDevelop - http://www.kdevelop.org/ - IDE livre para GNU/Linux e outros *nixes-like.

PythonWin - http://pywin32.sf.net/ - IDE que acompanha as extensões Win32 para Python (PyWin32). Oferece auto-completion e debugging, e tem recursos extras voltados à programação Windows (coletor de exceções para componentes COM criados, COM browser, geração de arquivos .py com informações sobre objetos COM (static dispatch), etc.).

PythonCard - http://pythoncard.sourceforge.net - é uma GUI para construção de aplicações multiplataforma em Windows, Mac OS X e Linux, usando a linguagem de programação Python. O lema de PythonCard é “coisas simples devem ser simples de fazer e coisas complexas devem devem ser possiveis”. É a ferramenta para quem deseja desenvolver aplicações gráficas de maneira rápida e fácil, com um mínimo de esforço e codificação; simples mas poderoso. Utiliza a biblioteca wxPython, mas separa a lógica do código da apresentação utilizando um tipo de arquivo de definição de recursos. (RômuloCampelo - 08/04/2005)

TruStudio - http://trustudio.unipro.ru e http://sourceforge.net/projects/trustudio - Esta IDE é um plugin para o Eclipse (mais informações sobre este acima), tornando o suporte a PHP e Python bem mais completo e poderoso.

PyScripter - http://mmm-experts.com/Downloads.aspx?ProductId=3 - Acompanha o conjunto de componentes python para Delphi (embora não requira que o Delphi esteja instalado para funcionar). Suporta debugging, auto-completion, navegação no código entre outros recursos. Na versão atual (3.31) o instalador parece ter um problema pois abre a IDE durante a instalação, diz que não pôde localizá-la e não cria um atalho, porém você pode criar um a partir do pasta onde foi instalada (geralmente C:Arquivos de ProgramasPythonForDelphi).

PyPE - http://pype.sourceforge.net/index.shtml - Não se trata de um IDE propriamente dito, mas é um editor Python, leve, funcional e rico em recursos interessantes e multiplataforma. Além disso, é desenvolvido utilizando wxPython.

 

Proprietários

Wing - http://www.wingware.com - Das IDEs proprietárias essa é uma das que mais gosto ( OsvaldoSantanaNeto ). A empresa wingware recentemente lançou o wingide101 para auxiliar no ensino de python e é uma versão com menos recursos que as versões professional e personal, mas que tem funcionalidades interessantes, como depurador gráfico, shell interativo. Segue o link: http://wingware.com/wingide-101/index

Komodo - http://www.activestate.com - Essa é outra IDE bem poderosa também. Trabalha com outras linguagens além de Python e roda em Linux e Windows. Existe uma licença gratuita que pode ser usada para aprendizado.

BlackAdder - http://www.thekompany.com/products/blackadder/ - Feita pelo pessoal que desenvolve o KDE.

 

Editores de texto

vim - http://www.vim.org/ - Esse é o que eu uso ( OsvaldoSantanaNeto ). Tem em todo GNU/Linux e é altamente configurável.

Emacs - http://www.gnu.org/software/emacs/emacs.html - Esse editor é muito difícil de se usar (assim como o vim também), mas uma vez que se aprende a usá-lo ele pode se tornar uma IDE Python poderosíssima, principalmente em modo Python (http://sourceforge.net/projects/python-mode/). Mais “Emacs Goodies” em http://www.python.org/emacs/ ou na propria Wiki em PythonComEmacs.

SciTE - http://www.scintilla.org/SciTE.html - Excelente editor de textos voltado para programação. Suporta uma grande lista de linguagens, pode rodar e debugar os programas, é fácil de usar e é muito configurável. Disponível para Windows e X (ambiente gráfico dos UNIXes).

jext - http://www.jext.org/ - Muito bom editor! Suporta muitas linguagens e possui plugins para Python (executar, por exemplo).

joe - http://sourceforge.net/projects/joe-editor/ - Editor de texto para dinossauros -) Utiliza os mesmos comandos do WordStar, SideKick, etc. Disponivel via apt-get e emerge. (NiloMenezes).

Uma lista com outros (muitos) editores podem ser encontrados em http://www.python.org/moin/PythonEditors

Autor: Eduardo De Oliveira Padoan

Este texto foi retirado do site PythonBrasil.org, modificado por Philip Sampaio e está disponível sob os termos da Creative Commons Attribution 2.5 exceto quando explicitamente especificado outra licença.

 

Hello World!

Arquivado em: Introdução — Etiquetas HTML:, , , , — Philip Sampaio @ 3:14 am

Primeiro post!

Espero ajudar ao máximo aqueles que desejam aprender a programar em Python - principalmente aplicativos com interfaces gráficas.

Críticas e opiniões seram muito bem vindas.
Os posts serão em grande parte escritos em português do Brasil.

Boa leitura.

Blog no WordPress.com.