Pular navegação

Tag Archives: python

Exemplo utilizando máscara de texto.

Exemplo utilizando máscara de texto.

Hoje é um dia propício pra postagem, não me pergunte o porque.
Vou começar mostrando como se aplica máscara de entrada em um campo de texto usando uma classe pronta. Encontrei essa classe em um fórum. Provavelmente surgiu deste projeto brasileiro
(já que um dos autores é o mesmo da classe).
Siga as regras da licença.

Copie o código e salve com o nome de MaskEntry.py

#
# Copyright (C) 2006 Async Open Source
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
# USA
#
# Author(s): Johan Dahlin <[EMAIL PROTECTED]>
#

import string
import sys

import gobject
import pango
import gtk

class MaskError(Exception):
    pass

(INPUT_CHARACTER,
 INPUT_ALPHA,
 INPUT_DIGIT) = range(3)

INPUT_FORMATS = {
    'a': INPUT_ALPHA,
    'd': INPUT_DIGIT,
    'c': INPUT_CHARACTER,
    }

class MaskEntry(gtk.Entry):
    def __init__(self):
        gtk.Entry.__init__(self)
        # It only makes se
        self.modify_font(pango.FontDescription("monospace"))
        self.set_property('editable', True)
        self.set_size_request(90, -1)

        self.connect('insert-text', self._on_insert_text)
        self.connect('delete-text', self._on_delete_text)

        # List of validators
        #  str -> static characters
        #  int -> dynamic, according to constants above
        self._validators = []
        self._interactive_input = True
        self._mask = None

    # Callbacks

    def _on_insert_text(self, editable, new, length, position):
        if not self._interactive_input:
            return

        if length != 1:
            print 'TODO: paste'
            self.stop_emission('insert-text')
            return

        position = self.get_position()
        next = position + 1
        validators = self._validators
        if len(validators) <= position:
            self.stop_emission('insert-text')
            return

        validator = validators[position]
        if validator == INPUT_CHARACTER:
            # Accept anything
            pass
        elif validator == INPUT_ALPHA:
            if not new in string.lowercase:
                self.stop_emission('insert-text')
                return
        elif validator == INPUT_DIGIT:
            if not new in string.digits:
                self.stop_emission('insert-text')
                return
        elif isinstance(validator, str):
            self.set_position(next)
            self.stop_emission('insert-text')
            return

        self.delete_text(position, next)

        # If the next position is a static character and
        # the one after the next is input, skip over
        # the static character
        if len(validators) > next + 1:
            if (isinstance(validators[next], str) and
                isinstance(validators[next+1], int)):
                # Ugly: but it must be done after the parent
                #       inserts the text
                gobject.idle_add(self.set_position, next+1)

    def _on_delete_text(self, editable, start, end):
        if not self._interactive_input:
            return
        if end - start != 1:
            print 'TODO: cut/delete several'
            self.stop_emission('delete-text')
            return

        validator = self._validators[start]
        if isinstance(validator, str):
            self.set_position(start)
            self.stop_emission('delete-text')
            return

        self.insert_text(' ', end)
        return False

    # Public API

    def set_mask(self, mask):
        """
        Sets the mask of the Entry.
        The format of the mask is similar to printf, but the
        only supported format characters are:
        - 'd' digit
        - 'a' alphabet, honors the locale
        - 'c' any character
        A digit is supported after the control.
        Example mask for a ISO-8601 date
        >>> entry.set_mask('%4d-%2d-%2d')
        HACK for erase data > set_mask('%0d') 
        

        @param mask: the mask to set
        """

        self._mask = mask
        if not mask:
            return

        input_length = len(mask)
        keys = INPUT_FORMATS.keys()
        lenght = 0
        pos = 0
        while True:
            if pos >= input_length:
                break
            if mask[pos] == '%':
                s = ''
                format_char = None
                # Validate/extract format mask
                pos += 1
                while True:
                    if mask[pos] not in string.digits:
                        raise MaskError(
                            "invalid format padding character: %s" % mask[pos])
                    s += mask[pos]
                    if mask[pos+1] in INPUT_FORMATS:
                        format_char = mask[pos+1]
                        break
                    pos += 1
                pos += 1
                self._validators += [INPUT_FORMATS[format_char]] * int(s)
            else:
                self._validators.append(mask[pos])
            pos += 1

        s = ''
        for validator in self._validators:
            if isinstance(validator, int):
                s += ' '
            elif isinstance(validator, str):
                s += validator
            else:
                raise AssertionError
        self.set_text(s)

    def get_field_text(self):
        """
        Get the fields assosiated with the entry
        if a field is empty it'll return an empty string
        otherwise it'll include the content

        @returns: fields
        @rtype: list of strings
        """
        if not self._mask:
            raise MaskError("a mask must be set before calling get_field_text")

        def append_field(fields, field_type, s):
            if s.count(' ') == len(s):
                s = ''
            if field_type == INPUT_DIGIT:
                s = int(s)
            fields.append(s)

        fields = []
        pos = 0
        s = ''
        field_type = -1
        text = self.get_text()
        validators = self._validators
        while True:
            if pos >= len(validators):
                append_field(fields, field_type, s)
                break

            validator = validators[pos]
            if isinstance(validator, int):
                s += text[pos]
                field_type = validator
            else:
                append_field(fields, field_type, s)
                s = ''
                field_type = -1
            pos += 1

        return fields

    def set_text(self, text):
        """
        Sets the text of the entry

        @param text:
        """
        self._interactive_input = False
        try:
            gtk.Entry.set_text(self, text)
        finally:
            self._interactive_input = True

    def delete_text(self, start, end):
        """
        Deletes text at a certain range

        @param start:
        @param end:
        """
        self._interactive_input = False
        try:
            gtk.Entry.delete_text(self, start, end)
        finally:
            self._interactive_input = True

    def insert_text(self, text, position=0):
        """
        Insert text at a specific position

        @param text:
        @param position:
        """
        self._interactive_input = False
        try:
            gtk.Entry.insert_text(self, text, position)
        finally:
            self._interactive_input = True

def main(args):
    win = gtk.Window()
    win.set_title('gtk.Entry subclass')
    def cb(window, event):
        print 'fields', widget.get_field_text()
        gtk.main_quit()
    win.connect('delete-event', cb)

    widget = MaskEntry()
    widget.set_mask('%2d/%2d/%4d')

    win.add(widget)

    win.show_all()

    widget.select_region(0, 0)
    gtk.main()

if __name__ == '__main__':
    sys.exit(main(sys.argv))

Depois disso, você poderá testa-la rodando normalmente, assim:
$ python MaskEntry.py

Para inseri-la no seu próprio programa, faça como no exemplo:

        self.dtaemi     = MaskEntry()
        self.dtaemi.set_mask('%2d/%2d/%4d')
        self.hboxDtasBusca.pack_start(self.dtaemi,False,False,0)
        texto = gtk.Label()
        texto.set_text("e")
        self.hboxDtasBusca.pack_start(texto,True,True,0)

        self.dtavenc    = MaskEntry()
        self.dtavenc.set_mask('%2d/%2d/%4d')
        self.hboxDtasBusca.pack_start(self.dtavenc,False,False,0)

Na primeira linha é criada a entrada de texto que receberá a máscara da classe.
Em seguida é configurada a máscara para esse objeto(%2d significa 2 dígitos).
No meu exemplo eu adicionei à um hbox criado anteriormente.
Pronto, tá feito.

Obs.: Se você selecionar um “MaskEntry” utilizando a tecla tab, ele selecionará todos os campos e não conseguirá apagar e voltar para o primeiro espaço.

Neste tutorial irei ensinar como criar uma ListStore em Python, utilizando o criador de interfaces Glade e PyGTK.

Primeiro crie uma interface como esta:

Salve com o nome que você quiser(no meu exemplo, eu salvei como Exemplo1.glade).

Em seguida crie os sinais da interface:

Feito isso, abra seu editor/IDE e insira o código comentado:

#!/usr/bin/env python
#-*- encoding: utf8 -*-

#Criação de uma liststore em Python, com PyGTK e Glade.
#Autor: Philip Sampaio

import gtk
import gtk.glade
import pygtk

pygtk.require("2.0")

class ListStoreSimples(object):
    def __init__(self):
        #Função de início.. é a primeira a ser carregada
        interface             =     gtk.glade.XML("Exemplo1.glade")
        self.winListStoreSimples    =    interface.get_widget("winListStoreSimples")
        self.entNome                =    interface.get_widget("entNome")
        self.entEmail            =    interface.get_widget("entEmail")
        self.trvListStore        =    interface.get_widget("trvListStore")

        #Montando a ListStore(ou tabela, como quiser)
        #A linha abaixo diz cria um modelo de liststore com 2 colunas, ambas sendo strings
        self.mdlListStore = gtk.ListStore( str, str)
        #A linha abaixo configura o modelo da treeview com o modelo acima
        self.trvListStore.set_model(self.mdlListStore)

        #Colocando as colunas
        colunaNome     = gtk.TreeViewColumn("Nome",gtk.CellRendererText(), text=0)
        colunaEmail    = gtk.TreeViewColumn("Email",gtk.CellRendererText(), text=1)
        #Adiciona à nossa treeview (trvListStore)
        self.trvListStore.append_column(colunaNome)
        self.trvListStore.append_column(colunaEmail)

        #Dicionário de conexões
        dic = {
            'on_winListStoreSimples_destroy' : ( self.on_winListStoreSimples_destroy ),
            'on_btnAdicionar_clicked'         : ( self.on_btnAdicionar_clicked)
            }

        #Conecta os sinais
        interface.signal_autoconnect(dic)
    def main(self):
        #Inicia o loop GTK
        self.winListStoreSimples.show_all()
        gtk.main()

    def on_btnAdicionar_clicked(self,widget):
        #Sinal de clique do btnAdicionar
        nome     = self.entNome.get_text()
        email     = self.entEmail.get_text()
        #Preste atenção: você irá adicionar os dados no MODELO
        self.mdlListStore.append([ nome, email])

        #As linhas comentadas abaixo são de exemplo.
        """info = [("Philip Sampaio","philip.sampaio@gmail.com"),
                ("Fulano"         ,"fulano@gmail.com"),
                ("Maria"         ,"Maria@gmail.com"),
                ("João"             ,"Joao@gmail.com")]
        for coluna in info:
            print coluna[0], coluna[1]
        """
    def on_winListStoreSimples_destroy(self,widget):
        #funcao para parar o loop gtk e encerrar o programa
        self.winListStoreSimples.hide_all()
        gtk.main_quit()

if __name__ == '__main__':
    teste = ListStoreSimples()
    teste.main()

O resultado deve ser algo como isto:
Fácil, não?
Teste e estude o código! Pergunte se precisar de ajuda!

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.