Pular navegação

Vou fazer uma rápida apresentação sobre este IDE.

É um IDE extremamente rápido! Possui syntax highlighting(deixa o código colorido e mais fácil de vizualizar), suporta várias linguagens, pode compilar e executar os programas(ou até páginas web.. executa em um navegador) e etc.

O que mais chama atenção é a velocidade e estabilidade.

Um Screenshot do programa:

Geany IDE

Geany IDE

A versão em desenvolvimento do emesene, mensageiro instantâneo para redes Windows Live MessengerTM, está cheia de novidades, como o suporte ao novo protocolo usado pela MicrosoftTM(msnp15). Se você teve algum problema para se logar, é por causa deste protocolo e as vezes dava problema até no Live MessengerTM.

Outra novidade é que as cores, e inclusive os gradientes, do MSN Plus! já estão disponíveis nesta nova versão(versões de testes). O suporte a webcams está avançando… você já pode visualizar a webcam de seu amigo =D (embora eu não tenha testado).

Para testar as versões em desenvolvimento do emesene, você deve instalar o Subversion que é um “controle de versões”.

Para isto, abra seu terminal e digite:

Para quem usa Ubuntu ou Debian, etc:

#apt-get install subversion

Para quem usa Red Hat, Fedora:

#yum install subversion

Para obter obter o emesene-trunk(trunk é o nome dado a versões “não oficiais”) faça:

$svn co https://emesene.svn.sourceforge.net/svnroot/emesene/trunk/emesene/ emesene-trunk

Este comando copiará todo o código fonte do emesene e salvará na pasta emesene-trunk(criada com o mesmo comando). Em seguida:

$cd emesene-trunk
e
$./emesene

Você perceberá que não é muito conveniente ficar fazendo isso toda vez que for iniciar o programa. Então crie um lançador apontando para o emesene ;D.

Para manter os códigos atualizados, você deve entrar na pasta emesene-trunk e digitar o comando svn up.

Lembre-se que estas são versões em desenvolvimento e podem ser muito instáveis! Recomenda-se usar a versão dos repositórios da sua distro!
Quem deseja estudar Python e a biblioteca PyGTK, vai se deliciar com esta belezura.
Para mais informações sobre o desenvolvimento deste (ótimo) software, acesse: http://emesene.org/smf/

Até mais.

Se algum dia você passou por este blog, percebeu que ele ficou muitíssimo tempo sem posts! Pois é, eu tive alguns problemas pessoais que me deixaram sem muito ânimo pra seguir postando aqui.

Mas agora estou de volta, e cheio de idéias! Vou mudar o foco do blog para ficar algo mais amplo…

Vou falar sobre tudo que puder(e se o tempo deixar!).

Então é isso ai, let’s rock baby!

Sim, eu desenvolvo em Delphi! Preferiria aprender Python no meu técnico, mas eles consideram “fora de mercado”. Querem criar mão-de-obra barata(Ok, você pode ganhar muito com isso!).

Mas, como diz uma grande amiga minha, nem tudo é como agente quer… Tenho que usar Windows contra a minha vontade, mas tudo bem. Conhecimento que vier é lucro.

A dica está aqui, e serve para quem está com problemas em instalar pelo método ensinado aqui.

Em breve eu mostro com instalar no Lazarus.

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.

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/

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.

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

Idlehttp://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.

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

Pidahttp://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.

Eric4http://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-Constructorhttp://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.

Eclipsehttp://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/

EasyEclipsehttp://www.easyeclipse.org/site/distributions/python.html

DrPythonhttp://drpython.sourceforge.net/ – usa wxPython. Criado para ser utilizado em escolas.

IPythonhttp://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.

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

PythonWinhttp://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.).

PythonCardhttp://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)

TruStudiohttp://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.

PyScripterhttp://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).

PyPEhttp://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

Winghttp://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

Komodohttp://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.

BlackAdderhttp://www.thekompany.com/products/blackadder/ – Feita pelo pessoal que desenvolve o KDE.

 

Editores de texto

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

Emacshttp://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.

SciTEhttp://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).

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

joehttp://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.

 

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.