teste

Anúncios

Threads com PyGTK

Já falei um pouco de thread em python; agora vamos falar de threads com pygtk.

Como uma introdução, analise o código abaixo. Veja se lhe parece correto.

#! /usr/bin/env python
# -.- coding: utf-8 -.-
import gtk
import pygtk

continua=None
def iniciar(botao, texto):
    global continua
    continua=True
    x=0
    while continua:
        texto.set_text(str(x))
        x+=1

def parar(botao):
    global continua
    continua=False

# criando os componentes
win=gtk.Window()
box=gtk.VBox()
texto=gtk.Entry()
btinicia=gtk.Button("iniciar" )
btpara=gtk.Button("interromper" )

# ativando os eventos
btinicia.connect("clicked", iniciar, texto)
btpara.connect("clicked", parar)
win.connect("destroy",gtk.main_quit)

# encaixotando tudo
box.pack_start(texto)
box.pack_start(btinicia)
box.pack_start(btpara)
win.add(box)

# exibindo tudo
win.show_all()

# iniciando o loop principal do GTK
gtk.main()

O que deveria acontecer ao executar esse código? Uma janela com uma caixa de texto, um botão “iniciar” e um botão “interromper”.

Clicando no “iniciar”, um loop inicia e começa a mudar o conteúdo da caixa de texto para “1”, “2” e assim por diante até que se clique em “interromper”.

Se quiser executar o código, fique à vontade. Mas vou adiantar aqui que isso não vai dar certo. Ao clicar em “iniciar”, o controle do programa passa para o loop sem fim, e você nem vê a caixa de texto sendo atualizada e nem consegue mais clicar no botão “interromper”. Simplesmente seu programa pára de responder.

python – loop com xrange()

No artigo anterior, eu apresentei um código em que fazia um loop while incrementando uma variável. Sobre esse loop, fiz o seguinte comentário:

“Quanto ao loop no método run(), cabe um comentário aqui: na minha infinita ignorância, sempre usei “for x in range(n)” para fazer um loop com n iterações. Não me ocorria que range(n) retorna uma lista com n elementos. Como nós queremos aqui fazer muitas e muitas iterações, a lista gerada num loop “for x in range(n)” iria ocupar muita memória e não teria utilidade nenhuma no nosso código.”

Acontece que, mesmo ali, minha “infinita ignorância” ainda falou mais alto. Acontece que acabei de tropeçar na função xrange(), de utilização idêntica à da função range(). A diferença é que, em vez de retornar uma lista como range(), retorna um objeto que gera os números do intervalo sob demanda. Conforme a documentação, é ligeiramente mais rápida e mais eficiente com a memória.

Resultado do comando pydoc xrange no meu terminal:

Help on class xrange in module __builtin__:

class xrange(object)
|  xrange([start,] stop[, step]) -> xrange object
|
|  Like range(), but instead of returning a list, returns an object that
|  generates the numbers in the range on demand.  For looping, this is
|  slightly faster than range() and more memory efficient.
|
|  Methods defined here:
|
|  __getattribute__(...)
|      x.__getattribute__('name') <==> x.name
|
|  __getitem__(...)
|      x.__getitem__(y) <==> x[y]
|
|  __iter__(...)
|      x.__iter__() <==> iter(x)
|
|  __len__(...)
|      x.__len__() <==> len(x)
|
|  __repr__(...)
|      x.__repr__() <==> repr(x)
|
|  __reversed__(...)
|      Returns a reverse iterator.
|
|  ----------------------------------------------------------------------
|  Data and other attributes defined here:
|
|  __new__ = <built-in method __new__ of type object at 0x815e620>
|      T.__new__(S, ...) -> a new object with type S, a subtype of T

Utilizando:

for num in xrange(3):
    print num

Agora posso dizer que o tamanho da minha “infinita ignorância” é igual a infinito -1 .

Exemplo de thread reaproveitando nossa árvore binária

No artigo sobre threads eu não coloquei nenhum exemplo “prático” de utilização de threads, então vou colocar aqui, misturando conteúdo dos artigos anteriores.

No artigo sobre árvores binárias, nossa classe era uma árvore binária que guardava palavras de um arquivo de texto, com um contador para a quantidade de ocorrências de cada palavra. O programa de teste para essa classe jogava o conteúdo de um arquivo na árvore, e depois de a ter carregado, mostrava todas as palavras em ordem alfabética. Vamos usar esta classe no nosso exemplo de thread.

Como eu queria montar uma árvore tão grande quanto possível, em vez de arrumar arquivos grandes para deles extrair palavras, resolvi fazer um gerador de palavras aleatórias. Vamos usar ele também.

A idéia: fazer um loop com um número muito grande de iterações. A cada iteração, uma palavra aleatória é criada e é adicionada à árvore. A classe da arvore tem um método para busca de palavras, arvbin.busca(), e ele será usado pelo nosso programa exemplo numa interface interativa. O usuário digita uma palavra e o programa diz se existe a palavra na árvore e a quantidade de ocorrências desta palavra.

O esquema do programa:

• passo 1 – gerar muitas palavras aleatórias, adicionando-as à árvore;
• passo 2 – apresentar um prompt para pesquisa de palavras na árvore.

Um problema se apresenta aqui: quantas palavras nós vamos gerar, e quanto tempo vai levar até que todas as palavras tenham sido geradas e a árvore esteja completa? Como o código é seqüencial, iniciamos o passo 1 e só após a sua conclusão é que entraremos no passo 2. A não ser que pudéssemos executar os dois ao mesmo tempo. É aí que entra a thread.

Threads em python

Neste artigo vamos falar de Threads em Python. Antes de começar, preciso avisar que estou escrevendo enquanto pesquiso sobre o tema. Não atribua a este artigo autoridade maior do que ele merece. O objetivo dele é compartilhar o aprendizado do autor. Isto significa que o que é mostrado aqui está correto, mas não te dispensa de pesquisar em outras fontes.

Feitas as ressalvas, voltemos ao tema.

Explicando de forma grosseira, thread é uma forma de você não deixar seu programa ‘travar’ enquanto executa uma tarefa demorada. Usando thread, voce pode colocar essa tarefa para correr em paralelo, enquanto seu código segue; como uma bifurcação, mas dentro do mesmo processo, compartilhando o mesmo espaço de programa, como as variáveis e tudo o mais.

Há duas formas de você adicionar funcionalidades de threads ao seu código: com o módulo thread ou com a classe threading.Thread.

Com o módulo thread, você chama o método thread.start_new_thread(func, args), onde func é a função que você escreveu e que vai ser executada pela thread, e args é um tupla com os argumentos para a sua função.

O módulo threading é uma ‘extensão’ do módulo thread. Ele implementa a classe Thread e, entre outros, seu método start(). O método start() vai (não diretamente) chamar o método run() com start_new_thread(). Há também mais de uma forma de usar threading.Thread:

• criando uma instância de threading.Thread() ou

• criando uma classe que herda de threading.Thread e sobrescrevendo o método run().

Na primeira forma:

from threading import Thread
def minha_funcao(algumacoisa):
    print algumacoisa

th=Thread( target=minha_funcao, args = ( 'qualquercoisa', ) )
th.start()

O construtor de Thread recebe, além de self, 6 argumentos (referência aqui), e entre eles:

• group: Deve ser sempre None, é reservado para uso em uma futura classe ThreadGroup;

• target: o método ou função que vai ser chamado em run();

• args: uma tupla com os argumentos que serão passados para a função em target.

Veja trecho do código de threading.py, localizado no meu sistema em /usr/lib/python2.5 .

Para ver onde fica o arquivo no seu sistema, veja o valor de threading.__file__

class Thread(_Verbose):

    __initialized = False
    # Need to store a reference to sys.exc_info for printing
    # out exceptions when a thread tries to use a global var. during interp.
    # shutdown and thus raises an exception about trying to perform some
    # operation on/with a NoneType
    __exc_info = _sys.exc_info

    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, verbose=None):
        assert group is None, "group argument must be None for now"
        _Verbose.__init__(self, verbose)
        if kwargs is None:
            kwargs = {}
        self.__target = target
        self.__name = str(name or _newname())
        self.__args = args
        self.__kwargs = kwargs
        self.__daemonic = self._set_daemon()
        self.__started = False
        self.__stopped = False
        self.__block = Condition(Lock())
        self.__initialized = True
        # sys.stderr is not stored in the class like
        # sys.exc_info since it can be changed between instances
        self.__stderr = _sys.stderr

Na segunda forma (herdando de threading.Thread), somente os métodos __init__() e run() podem ser sobrescritos.

# -.- coding: utf-8 -.-
from threading import Thread

class minhaThread(Thread):
    # sobrescrevendo o método __init__()
    def __init__(self, meu_argumento):
        # o metodo __init__ da superclasse
        # deve ser chamado para proceder
        # com a inicialização
        Thread.__init__(self)
        self.atributo=meu_argumento

    # sobrescrevendo o metodo run()
    def run(self):
        #insira seu codigo aqui
        print 'patata'

Para executar a thread, você cria uma instância de minhaThread() e chama o método minhaThread.start().

thr = minhaThread( 'algum argumento' )
thr.start()

Não estenderemos por agora o artigo, e não haverá aqui nenhum exemplo “funcional” de utilização de threads.

Por enquanto, ficam as referências de pesquisa:

Understanding Threading in Python

Using threads in PyGTK

Python Library Reference – 15.3.6 Thread Objects

Enquanto isso…

Estamos no ano 2008 DC. Toda a Internet foi ocupada pelos romanos… Toda? Não! Uma aldeia habitada por irredutíveis nerds resiste ainda e sempre ao invasor. E a vida não é fácil às guarnições de legionários romanos dos campos entrincheirados de Babaorum, Aquarium, Laudanum e Petibonum…

E a vida segue na nossa pequena e pacata aldeia

Brincando de arvore binária com Python

De repente me deu vontade de fazer uma árvore binária em python. Não sei por que, nem para quê, mas deu vontade.

Usei um exemplo que creio ter visto no livro “C A linguagem de Programação” de Brian Kernighan e Dennis Ritchie : contagem de palavras em um texto.

O livro fala de árvores binárias como alternativa, neste problema de contagens de palavras, à pesquisa binária. Numa pesquisa binária, pressupomos que a lista de valores está previamente ordenada. Isso não deve ocorrer com as palavras de um texto qualquer. Não sabemos nem mesmo a quantidade de palavras que podem estar contidas nesse texto, de modo que pode não ser muito eficiente rodar previamente um algoritmo de ordenação. A salvação então é a tal árvore binária.

No meu código abaixo, criei uma classe (arvbin) para representar os nós da árvore. Os atributos da classe são: a palavra, o contador de ocorrências da palavra, um apontador para a palavra menor e outro para a maior:

class arvbin:
    def __init__(self, Valor):
        self.Menor=None  #apontador para a palavra menor
        self.Maior=None  #apontador para a palavra maior
        self.conta=1     #conttador de ocorrências
        self.valor=Valor #a palavra