Krix Apolinário

Em maio do ano passado postei aqui no blog sobre o lançamento do livro Python Para Desenvolverores de autoria de Luiz Eduardo Borges e hoje eu venho dizer que ele lançou a segunda edição do livro que vem nessa nova edição com 107 páginas a mais, totalizando 360.

Li boa parte da primeira edição infelizmente parei por falta de tempo, mas a leitura desse livro vale a pena.

Novamente parabenizo o Luiz pelo livro e que ele e desejo que ele tenha o merecido reconhecimento.

Para fazer o download do livre acesse aqui.

“Já está disponível para download a segunda edição do livro Python para Desenvolvedores. A primeira edição foi uma iniciativa inédita, sendo o primeiro livro livre em português sobre a linguagem de programação. A publicação é distribuída sob uma licença Creative Commons, que ajuda garantir o direito autoral, ao mesmo tempo que permite copiar, distribuir, exibir e criar obras derivadas, democratizando o acesso ao conhecimento.Com mais de cem páginas a mais que a anterior, a nova edição traz vários assuntos inéditos e uma extensa revisão do conteúdo. Voltado para desenvolvedores que já tem conhecimento de programação, as 360 páginas do livro explicam de forma simples e objetiva, as tecnologias envolvendo a linguagem utilizadas em projetos. Os capítulos abordam entre outros tópicos, interfaces gráficas, aplicações para Internet e sistemas distribuídos.

Luiz Eduardo Borges, analista de sistemas com pós-graduação em Ciência da Computação pela Universidade do Estado do Rio de Janeiro, buscou a criação de um material abrangente, capaz de fornecer ao leitor explicações e exemplos práticos da maior parte do ferramental disponível na linguagem para o desenvolvimento de soluções de problemas comuns e alguns bastante incomuns de computação.”

FONTE

Oie gente, tudo bonzinho?

Desde setembro o Magnun iniciou em seu blog um curso de Python, tenho acompanhado o curso e a linguagem usada por ele é bem simples o que é ótimo principalmente para aqueles que estão iniciando.

Acesse o link do curso e aproveitem

Algo que venho constantemente usando em meus scripts Python é a manipulação de arquivos, seja criando ou acrescendo textos. Para isso vou usar um exemplo para começar a explicar:

Text = '''
192.168.2.32
192.168.2.63
192.168.2.86
192.168.2.90
'''
 
MyFile = open('/home/krix/list_ips.txt', 'w')
MyFile.write(Text)
MyFile.close()

O código acima cria o arquivo (ou se ele já existe o sobescreve) /home/krix/list_ips.txt inserindo o texto declarado na variável Text e em seguida o fecha. Parece bem simples não é?! E é. A manipulação de arquivos com Python é realmente bem simples.

A sintaxe da função open() é:

open(arquivo[, modo[, tamanho do buffer]])

O primeiro parâmetro arquivo é obrigatório e como se pode ver é o nome e/ou caminho do arquivo a ser aberto;

O segundo parâmetro modo, que não é obrigatório, será uma string que indicará o modo como o arquivo será aberto. São eles:

• r (read): O arquivo é aberto somente para leitura. Quando não informado o modo este será o padrão.

MyFile = open('/home/krix/list_ips.txt', 'r')
ReadingFile = MyFile.read()
MyFile.close()
print ReadingFile

• w (write): O arquivo é aberto somente para escrita e será bloqueado caso exista subescrevendo seu conteúdo e criado se não existir.

MyFile = open('/home/krix/list_ips.txt', 'w')
MyFile.write(Text)
MyFile.close()

• a (append): O arquivo é aberto somente para escrita contudo ao contrário do w que subescreve o conteúdo do arquivo ele irá acrescentar ao arquivo.

MyFile = open('/home/krix/list_ips.txt', 'a')
NewIPs = []
NewIPs.append(Text)
MyFile.write((' '.join(NewIPs))+"\n")
MyFile.close()

Todos os modos acima citados quando seguido do caracter mais (+) o arquivo será aberto tanto para leitura quanto para escrita.

Quando os modos r, w ou a estiver seguido do caracter b ou t isso indicará a forma de manupulação do arquivos, o b indicará que será binário e o t em texto e quando não informado o t será o padrão.

MyFile = open('/home/krix/list_ips.txt', 'w+')

MyFile = open('/home/krix/list_ips.txt', 'wb')

O terceiro parâmetro tamanho do buffer, também não obrigatório, e controla o comportamento do buffer do arquivo. Se 0 não será bufferizado, se 1 será bufferizado e se for um número positivo maior que 1 indicará o tamanho do buffer em bytes.

Acima usamos alguns métodos como o read, write e close mas não falamos nada sobre eles então abaixo irei dá uma definição a eles e a alguns outros métodos que julguei indispensáveis:

• read(): Lê o arquivo.

MyFile.read()

• readline(size): Lê uma só linha do arquivo. Size será a quantidade de caracteres que será lido na linha.

MyFile.readline()

• readlines(size): Lê todas as linhas do arquivo e retorna numa lista. Size será o número de bytes a ser lido.

MyFile.readlines()

• write(str): Escreve a string passada no arquivo.

MyFile.write(Text)

• writelines(): Escreve no arquivo todas as strings de uma lista.

MyFile.writelines(list)

O que seria o mesmo que:

for line in list:
    MyFile.writelines(line)

• close(): Fecha o arquivo.

MyFile.close()

No exemplo que dei mais acima quando falei sobre o modo a você percebeu que usei dois métodos que os quais ainda não tinha comentado, o join e o append. O join tem a função de concatenar uma string a outra o que seria justamente o que eu precisaria no código. O append adiciona um ítem ao final de uma lista. Dadas as definições vamos explicar: Se eu tivesse ignorado o append e usasse somente o join para adicionar o Text ao arquivo será que funcionaria sem problemas? Sim, mas sem problemas?!?! Humm, isso já seria relativo, se eu retirasse e dexasse o código assim:

MyFile = open('/home/krix/list_ips.txt', 'a')
MyFile.write((' '.join(Text))+"\n")
MyFile.close()

O arquivo ficaria assim:

1 9 2 . 1 6 8 . 2 . 3 2
1 9 2 . 1 6 8 . 2 . 6 3
1 9 2 . 1 6 8 . 2 . 8 6
1 9 2 . 1 6 8 . 2 . 9 0

Mas deixando como o exemplo inicial o arquivo ficaria assim:

192.168.2.32
192.168.2.63
192.168.2.86
192.168.2.90

Fico por aqui com o post, acho que já falei demais .

MyFile = open('/home/krix/list_ips.txt', 'a')
NewIPs = []
NewIPs.append(Text)
MyFile.write((''.join(NewIPs))+"\n")
MyFile.close()

Faz um tempinho que não escrevo nenhum post mas juro que não é má vontade, é que estou resolvendo umas bronquinhas mas prometo que vou procurar ficar mais presente.

Essa semana estava procurando sobre um determinado assunto e acabei encontrando uma dica passada pelo Petry em seu blog (que por sinal eu não conhecia), onde fala sobre o uso do TAB para auto completar as funções no interpretador Python, algo que é muito útil.

Para que fique por padrão em seu interpretador Python crie o arquivo $HOME/.pythonrc e insira o seguinte código:

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

Você também pode rodar esse código diretamento no interpretador Python mas fazendo isso, sempre que acessar terá que refazer e criando o arquivo não será necerrário. Contudo não podemos esquecer de declarar a variável indicando o local do .pythonrc no .bashrc, então adicione as linhas abaixo no $HOME/.bashrc :

PYTHONSTARTUP="$HOME/.pythonrc"
export PYTHONSTARTUP

Após isso basta restartar o shell e rodar o interpretador Python:

[krix@rogue]$ source /home/krix/.bashrc
[krix@rogue]$ python
Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> str. [TAB+TAB]
str.__add__(                      str.__init__(                     str.__subclasses__(               str.join(
str.__base__(                     str.__instancecheck__(            str.__subclasshook__(             str.ljust(
str.__bases__                     str.__itemsize__                  str.__weakrefoffset__             str.lower(
str.__basicsize__                 str.__le__(                       str._formatter_field_name_split(  str.lstrip(
str.__call__(                     str.__len__(                      str._formatter_parser(            str.mro(
str.__class__(                    str.__lt__(                       str.capitalize(                   str.partition(
str.__cmp__(                      str.__mod__(                      str.center(                       str.replace(
str.__contains__(                 str.__module__                    str.count(                        str.rfind(
str.__delattr__(                  str.__mro__                       str.decode(                       str.rindex(
str.__dict__                      str.__mul__(                      str.encode(                       str.rjust(
str.__dictoffset__                str.__name__                      str.endswith(                     str.rpartition(
str.__doc__                       str.__ne__(                       str.expandtabs(                   str.rsplit(
str.__eq__(                       str.__new__(                      str.find(                         str.rstrip(
str.__flags__                     str.__reduce__(                   str.format(                       str.split(
str.__format__(                   str.__reduce_ex__(                str.index(                        str.splitlines(
str.__ge__(                       str.__repr__(                     str.isalnum(                      str.startswith(
str.__getattribute__(             str.__rmod__(                     str.isalpha(                      str.strip(
str.__getitem__(                  str.__rmul__(                     str.isdigit(                      str.swapcase(
str.__getnewargs__(               str.__setattr__(                  str.islower(                      str.title(
str.__getslice__(                 str.__sizeof__(                   str.isspace(                      str.translate(
str.__gt__(                       str.__str__(                      str.istitle(                      str.upper(
str.__hash__(                     str.__subclasscheck__(            str.isupper(                      str.zfill(
>>> str.

Muito bom não é?! Mas antes de dá esse post como finalizado acho importante falar um pouco sobre os módulos que usamos para que isso ocorresse:

• readline: Este módulo permite a edição de linha de comando usando o GNU readline. O módulo readline define algumas funções para facilitar a leitura e escrita de arquivos de histórico do interpretador Python. Este módulo pode ser usado diretamente ou através do módulo rlcompleter, como fizemos aqui. Deste módulo fizemos uso de uma de suas funções a parse_and_bind(string) que, analisar e executar uma única linha de um arquivo.
• rlcompleter:  Este módulo define uma função de conclusão adequada para o módulo readline completando identificadores válidos Python e palavras-chave.

Agora porque o nome da variável adicionada no .bashrc foi PYTHONSTARTUP e não qualquer outra? Esta é uma variável de ambiente que influencia no comportamento da linguagem onde, o arquivo nela declarado é executado no mesmo espaço interactivo, onde os comandos são executados durante a sessão interativa (no caso o interpretador Python).

Você pode obter mais informações sobre esse e outros módulos e funções aqui.