Mas então vamos lá!
Essa dica é pra quem acha que não existe autocomplete em Python ou pelo menos fora de algum bom editor… Quem gosta de brincar no shell e ficar testando códigos pequenos, essa pode ser boa!
Abra o shell, interpretador e:

import readline
import rlcompleter
readline.parse_and_bind('tab: complete')


“Voyalá”!

Agora o seu TAB tem super poderes!

Até a próxima!

>>> import this

Traduzindo o que foi retornado:

Bonito é melhor que feio.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Plano é melhor que aglomerado.
Esparso é melhor que denso.
Legibilidade faz diferença.
Casos especiais não são especiais o bastante para quebrar as regras.
Embora a praticidade vença a pureza.
Erros nunca devem passar silenciosamente.
A menos que sejam explicitamente silenciados.
Diante da ambigüidade, recuse a tentação de adivinhar.
Deve haver um — e preferencialmente só um — modo óbvio para fazer algo.
Embora esse modo possa não ser óbvio à primeira vista a menos que você seja holandês.
Agora é melhor que nunca.
Embora nunca freqüentemente seja melhor que *exatamente* agora.
Se a implementação é difícil de explicar, é uma má idéia.
Se a implementação é fácil de explicar, pode ser uma boa idéia.
Namespaces são uma grande idéia — vamos fazer mais dessas!

E para quem ainda tem alguma esperança da linguagem começar a utilizar { chaves } no futuro, tente:
>>> from __future__ import braces
File "<stdin>", line 1
SyntaxError: not a chance

Se você sabe de mais alguma gracinha, poste nos comentários!!!

Antes vou tentar exemplificar!
Se fizermos:
import string
a = 'teste'
upper(a)
irá nos retornar um erro informando que o método upper() não existe, para que isso funcione devemos fazer:

string.upper(a)

ou seja,

módulo.método

Para que o primeiro código funcione, substituímos import string por from string import upper ou from string import *

Explicando teoricamente, ao fazer from módulo import método/atributo/*, os atributos e métodos dos tipos de módulos importados são importados diretamente para dentro do namespace local, ficando disponíveis diretamente, sem qualificação por nome do módulo. Enquanto da outra forma é necessário qualificar o módulo antes do método/atributo a ser utilizado.

Logo me surpreendi ao reparar que o Professor estava ensinando Python para os calouros, no primeiro momento achei a idéia bem interessante!

Eles estavam resolvendo uma lista de exercícios de manipulação de strings (procura, substituição, remoção, etc)…

Depois de uns 15 minutos de aula e o Professor resolvendo alguns exercícios (já estava no terceiro ou quarto), um aluno pergunta o que é aquele from string import * e se precisava ficar decorarando aqueles nomes split, replace, upper e lower.

Foi ai que um amigo que estava sentado ao meu lado disse: “Assim fica fácil, quando agente fez essa matéria não era só utilizar esses métodos, precisava implementá-los!“.

E é verdade, tudo bem que naquela época não tínhamos nem idéia do que é uma classe, objeto e seus métodos, afinal, em Pascal (linguagem procedural) não existe isso. Mas fizemos muitas funções e procedimentos para manipulação de strings, geração de séries numéricas, arquivos, listas, pilhas, árvores, aprendemos ponteiros (e depois sofremos um bocado com isso em C hehe), inclusive em arquivos separados para depois importá-los.

Mas aonde quero chegar?

Quem passou por isso de resolver esses problemas básicos na mão, tem pelo menos uma noção de como as linguagens resolvem um problema. E quem não viu isso, pensa que a linguagem faz mágica quando faço:

"isso eh um teste".replace("eh", "é") ?

Eu acredito e gosto de linguagens mais modernas como Python, mas não acho que ensiná-las no primeiro ano de um curso superior de Informática/Computação seja o melhor caminho, assim como Java (a POO não é fácil para quem está começando).

O programador não pode ser dependente de IDEs ou linguagens para resolver problemas, pelo menos não no começo para quem está aprendendo, pois pode atrapalhar seu raciocínio lógico e criatividade. Depois de saber de onde as coisas vem, tudo bem, ganha-se tempo e as preocupações devem ser outras.

Então por qual linguagem o estudante deve começar?

Deve começar sem linguagem (!?), na ponta do lápis e escrevendo algoritmos, praticando a lógica e raciocínio. Tipos de dados, atribuição, operadores, laços de repetição, condicionais, entrada/saída, criação de funções/procedimentos, recursividade, etc.

Já com algumas idéias fundamentais consolidadas, acho que uma boa escolha é a linguagem C, pois apresenta uma sintaxe fácil (boa parte das linguagens tem sua sintaxe baseada no C), além de ser extremamente útil (obviamente, com maior nivel de complexidade) diferentemente do Pascal.

Se o aluno lá do começo do texto tivesse criado um arquivo “meusProcedimentos.h” e no inicio do seu arquivo principal fizesse #include “meusProcedimentos.h” , ele com certeza não teria uma dúvida tão básica ou entenderia melhor a resposta dada pelo professor.

Mas quem sou eu para discutir a didática dos professores e o programa das matérias do curso de Informática da Universidade que estudo?

OBS.: Esse texto é apenas uma opinião do autor e totalmente passível de críticas e discordâncias.

Conta com uma boa documentação (http://nltk.sourceforge.net/index.php/Book) que auxilia o desenvolvimento, composto por leitores de corpus, tokenizers, stemmers, taggers, chunkers, parsers, wordnet, mais de 30 conjuntos de dados anotados amplamente usados de PLN (+300Mb).

Quando a manipulação com strings começa a ser tornar trabalhosa utilizando apenas o módulo String do Python, é a hora do NLTK entrar em cena.

INSTALAÇÃO

A instalação é bem simples, ter o Python instalado é um requisito.

Faça o download do código fonte em: http://prdownloads.sourceforge.net/nltk/nltk-0.9.2.tar.gz

Descompacte:
$ tar -zxvf nltk-0.9.2.tar.gz

Entre na pasta:
$ cd nltk-0.9.2

Utilize o instalador:
$ sudo python setup.py install

Isso feito, agora é necessário realizar um download maior (75MB) com os dados do NLTK: http://prdownloads.sourceforge.net/nltk/nltk-data-0.9.2.zip

Enquanto o download não termina, você pode criar a seguinte pasta:
$ sudo mkdir /usr/share/nltk

Após o término e descompactação dos arquivos, mova a pasta descompactada:
$ sudo mv data /usr/share/nltk

Altere a permissão da pasta para que os dados possam ser utilizados:
$ sudo chmod -R g+r /usr/share/nltk/data

——————————————————————–

Pronto, instalação completa no Linux!

——————————————————————-

Para utilizá-la, você deve importar o módulo no Python:
$ python
>>>import nltk

Existe um corpus em português que pode ser utilizado da seguinte forma:
>>>from nltk.corpus import floresta

Vamos coletar as palavras pertencentes a esse corpus:
>>>palavras = floresta.words()

Temos 211.852 palavras:
>>>len(palavras)

Por enquanto é só isso, pretendo em um próximo post apresentar alguma coisa interessante desse módulo.
Como ainda não o estudei muito bem, não tenho muita coisa. Mas como terei de usá-lo em meu Trabalho de Conclusão de Curso (Investigação e Implementação De Um Sistema Gerador de Expressões Regulares A Partir De Um Conjunto De Expressões Em Linguagem Natural) provavelmente terei alguma coisa para mostrar em breve e quem sabe também não falo sobre o meu TCC.

Referências:
http://nltk.sourceforge.net/

O André Noel realizou duas palestras, sobre a filosofia software livre e apresentou as novas funcionalidades do novo Ubuntu.

Outra palestra do dia foi do Eduardo Pezutti sobre o sistema gerenciador de conteúdo (CMS): Drupal. Voltado para a linguagem PHP.

Por último, o Lucas Veloso apresentou diversas alternativas livres para a administração de ambientes heterogêneos. Ferramentas para verificação de integridade/recuperação de HD, memória, cópia de sistemas operacionais em ISO (bem legal o System Imager).

Saldo positivo p/ evento e p/ SL!