Desenvolvimento Código Aberto

Uma Package (pacote) é uma coleção de módulos relacionados armazenados em um diretório e subdiretórios.

Um __name__ é um __name__, exceto quando é __ main__

Dentro de um módulo, o nome do módulo (como uma string) é armazenado no nome global __ name__.

Mas há uma exceção: Se o arquivo de módulo é executado como um programa a partir da  linha de comando, Python define __ name__ do módulo para ‘__main__‘.

Este recurso é útil para incluir código (geralmente o código de teste) em um arquivo de módulo que é executado somente quando você iniciar o módulo a partir da linha de comando (digitando: python nomedomodulo.py).

O código fica assim:

if __name__ == '__main__':

do something

Quando você inclui o código que é executado somente sob essas circunstâncias, você não tem que remover o código quando você importa o módulo. Isso porque quando um módulo é importado, __ name__ é o nome do módulo, não ‘__main__‘.

Este código vai fora de quaisquer definição de função ou declarações de importação no módulo, geralmente no final do módulo.

Os efeitos de pacotes

Os pacotes são uma outra maneira de tirar vantagem da capacidade do Python para ocultar a complexidade.

Pacotes tem alguns recursos úteis:

• Um pacote tem seu próprio namespace.
• Nomes definidos dentro de um módulo,  incluindo nomes de módulos não conflitam com os nomes definidos em outro lugar.
• Os pacotes podem conter módulos.
• Os pacotes podem conter sub pacotes.
• Pacotes são ideais para armazenar e organizar uma série de características relacionadas.

Requisitos e Orientações Para os Pacotes:

• Um pacote vive dentro de um diretório e seus sub pacotes vivem dentro de sub diretórios desse diretório (em geral).
• Assim como um módulo de arquivos nomeia o módulo, um pacote de diretório nomeia o pacote.
• Isso permite importar itens do pacote, usando a importação no formato packagename.modulename.
• Um diretório do pacote deve conter um arquivo chamado __ init__.py.

No caso mais simples, __ init__.py é apenas um arquivo vazio. Mas, muitas vezes, contém código que inicializa o pacote. Por exemplo, a melhor maneira de importar um específico sub módulo com um pacote ou sub pacotes particular é carregá-los no arquivo __init__.py.

O arquivo __init__.py às vezes contém a lista: __ all__

Esta lista ajuda código Python executado em diferentes sistemas operacionais. Quando você inclui nomes de módulos em __all__, o comando de importação: from packagename import * – importa apenas estes módulos.

Sobre diretórios e pacotes especiais

Quando Python é instalado, ele cria diretórios específicos para pacotes. Se você armazenar pacotes em um desses diretórios especiais de pacote, é menos provável ter problemas se os seus nomes de pacotes são os mesmos que os nomes dos módulos em outros lugares no caminho Python.

• Diretório: lib/local-python/  – Este diretório é para pacotes que funcionam da mesma maneira com todas as versões do Python.
• Diretório: Lib/pythonXX/site-packages/ – Este diretório é para os pacotes que dependem da versão do Python. Alterações XX representam o número da versão do Python.

Estrutura de Packages

Você pode ver melhor como é uma estrutura de packages Python na imagem abaixo:

 Exemplo:

Neste exemplo criamos um projeto chamado Prj_Dev01 e na raiz do projeto temos o modulo principal.py, logo temos um pacote chamado devaberto(em Python uma package é apenas um diretório que contém o arquivo __init__.py) e dentro dele temos um modulo chamado msg.py e o arquivo de controle do pacote chamado __init__.py.

Python

Principal.py

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Principal.py

# Importa pacote
import devaberto.msg

# Importa OS
import os

# Limpa a tela
os.system("clear")

print "Modulo Principal"

print "\n"

devaberto.msg.menssagem("Minha menssagem")
devaberto.msg.msg2('menssagem2')

# Cria uma espera no terminal
raw_input()

__init__.py

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto

__all__ = ['msg']
# Importa pacote
import msg

msg.py

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# msg.py

def menssagem (x):
     print x

def msg2(x):
     print x
     print x

Em matemática, ciência da computação, linguística, e filosofia um TUPLE é uma lista ordenada de elementos. Na teoria dos conjuntos, um (ordenado) n-tuple é uma sequência (ou lista ordenada) de n elementos, onde n é um número inteiro não negativo.

Em linguagens de programação, tais como Python, um TUPLE (pronuncia TUH-pul) é um conjunto ordenado de valores. O separador para cada valor é uma vírgula. Os usos comuns para o TUPLE como um tipo de dados são:

• A passagem de uma série de parâmetros a partir de um programa para outro.
• A que representa um conjunto de atributos de valor em um banco de dados relacional.  Tuplas podem conter uma mistura de outros tipos de dados.

Uma tupla (em português)  é uma sequência de valores. Os valores podem ser de qualquer tipo, e eles são indexados por números inteiros, então nesse aspecto tuplas são muito parecidas com listas. A diferença importante é que as tuplas são imutáveis​​.

Sintaxe:

tuples = ( 0, “STRING”)

Exemplo:

Neste exemplo utilizamos uma tupla para passar parâmetros para exibir uma simples saída de tela.

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# tuplas.py

# Importa OS
import os

# Importa Cores
from termcolor import colored

# Limpa a tela
os.system("clear")

# Declara variave Tuples
# Tuples é otimo para enviar parametros

t =  (10,20,70,"blue","yellow","red","green","white","cyan")

# Monta saida de tela usando tuplas

print colored("Lista\n".center(t[2]), t[4])

print colored("codigo".rjust(t[0]), t[3]),   colored("Banda".rjust(t[1]), t[3]),  colored("Album".rjust(t[1]), t[3]),  colored("Vendas\n".rjust(t[1]), t[3])

print colored("14242".rjust(t[0]), t[7]),   colored("Metallica".rjust(t[1]), t[6]),  colored("Load".rjust(t[1]), t[8]),  colored("(0) Zero\n".rjust(t[1]), t[5])

print colored("14245".rjust(t[0]), t[7]),   colored("Metallica".rjust(t[1]), t[6]),  colored("Kill \'em All".rjust(t[1]), t[8]),  colored("5.000.000".rjust(t[1]), t[5])

Se um erro ocorrer dentro da clausula TRY então automaticamente o interpretador executa a instrução EXCEPT, existem vários outros parâmetros  de tratamento de exceções em Python.

Python – Try…Except…Raise

A declaração RAISE permite ao programador forçar uma exceção especifica.

Sintaxe:

TRY:

instrução

EXCEPT:

instrução

Exemplo:

Neste exemplo simplesmente geramos duas exceções clássicas, a primeira é uma divisão por zero e a segunda onde forçamos um erro no qual nos definimos uma mensagem exclusiva.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# erros.py

# Importa OS
import os

# Importa Cores
from termcolor import colored

# Limpa a tela
os.system("clear")

# Tratamento de erros

numero1 = 5
numero2 = 0

# Tratamento de erros -  Divisões por 0 geram erro.

print colored("Erro numero 1: Não para a execução do programa\n".center(70), "yellow")

try:
   print  numero1 / numero2
except:
   print colored("Impossivel dividir por zero.","red", attrs=["reverse", "blink"])

# Criando um novo Erro

print colored("Erro numero 2: Para a execução do programa\n".center(70), "yellow")

try:
    raise NameError( colored("Este é o meu novo erro.\nErro em outra linha." , "red"))
except NameError:
    print colored("Erro gerado propositalmente\nErro linha 2.\nErro linha 3.", "red", attrs=["reverse","blink"])
    raise

Python torna muito simples a tarefa de trabalhar com arquivos.

open () – retorna um objeto de arquivo, e é mais comumente usado com dois argumentos:

Sintaxe:

open (nome do arquivo, modo).

Modos de Arquivos

• ‘r’ –  quando o arquivo só será lido.
• ‘w’ –  para apenas escrever (um arquivo existente com o mesmo nome será apagado).
• ‘a’  – abre o arquivo para anexar (append).
• ‘r +’ –  abre o arquivo para leitura e escrita.
• ‘b’ – anexado ao modo abre o arquivo em modo binário.

Instruções

read () – Para ler o conteúdo do arquivo.

seek () – Posiciona o cursor em um ponto do arquivo: seek (colunas, posição). A posição 0 é o  início do arquivo, 1 usa a posição do arquivo atual e 2 usa o final do arquivo como ponto de referência. Se a posição é omitida o padrão é 0.

readline () – Lê uma única linha do arquivo.

write (string) – Escreve o conteúdo da string para o arquivo, retornando o número de caracteres escritos.

close () – Para fechar o aquivo e liberar todos os recursos do sistema tomados pelo arquivo aberto.

Exemplo:

Neste exemplo você deve primeiro criar um arquivo texto no mesmo diretório de onde executa seu programa, para este exercício vamos abrir o arquivo, ler o arquivo, gravar uma linha no final do arquivo e fechar o arquivo:

Python

Arquivo #1 – texto.txt

Desenvolvimento Aberto

Topicos

Ler um texto
escrever um texto

Arquivo #2 – Código Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# arquivo.py

# Importa OS
import os

# Importa Cores
from termcolor import colored

# Limpa a tela
os.system("clear")

#Lê um texto

with open("texto.txt","r+") as arquivo:
      texto = arquivo.read()

print colored("Texto\n".center(70),"yellow")
print colored(texto,"blue")

print colored("Escreve Linha\n".center(70),"yellow")

# Escreve um arquivo
# Abre o arquivo
arquivo = open("texto.txt","r+")

# Posiciona no final do
arquivo. arquivo.seek(0,2)

# Escreve no Arquivo
arquivo.write("Adiciona uma Linha\n")

# Fecha um arquivo
arquivo.close()

# Lê o arquivo novamente
with open("texto.txt","r+") as arquivo:
      texto = arquivo.read()
print colored(texto,"green")

Se você quiser mais controle sobre a formatação de sua saída do que simplesmente imprimindo valores separados por espaços e também colorir os textos de saida no terminal do linux.

A função str () é utilizado para retornar representações de valores que são bastante legível.

A função repr () destina-se a gerar representações que podem ser lidos pelo interpretador  para os objetos que não têm uma representação específica para o consumo humano. O repr () de uma string adiciona aspas e barras invertidas.

o str.rjust(), que justifica a direita uma string em um campo de uma determinada largura, preenchendo-a com espaços à esquerda. Existem métodos semelhantes str.ljust () e str.center ().

() str.format, os colchetes e caracteres dentro deles (chamados de campos de formato) são substituídos com os objetos passados ​​para o método

O metodo str.zfill(), que preenche uma string numérica com zeros à esquerda.

Termcolor (modulo), proporciona formatação ANSII e permite a saída de cores no terminal, usando a função colored(). O modulo termcolor não vem instaldo por default  e precisa ser instalado.

Python – Termcolor

Instalar o Modulo TermColor:

1. Faça o download do arquivo: https://pypi.python.org/pypi/termcolor.
2. Descompacte o arquivo e entre na pasta descompactada termcolor.
3. Pelo terminal navegue a o diretorio descompactado.
4. Digite: sudo python setup.py install.
5. O modulo termcolor esta pronto para uso.

Exemplo:

Neste exemplo criamos duas Arrays e formatamos a saída de tela usando funções de tabulação e letras coloridas no terminal do Linux:

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Elegante.py

# Importa OS
import os

# Importa Cores
from termcolor import colored

# Limpa a tela
os.system("clear")

# Cria Arrays
bandas = ["Alice in Chains", "Nirvana",  "Stone Temple Pilots", "SoundGarden", "Pearl Jam", "Screaming Trees"]

baladas =['Down in a Hole', "Something in the way", "Creep", "Black Hole Sun", "Black", "Dollar Bill"]

#imprime a tela
print colored("Baladas Grunge:\n",'blue', attrs=['reverse','blink'])

print colored("Lista das baladas classicas do anos 90\n".center(70),"yellow")

print colored("{0:10s} {1:25s} {2:5s} {3:25s}".format("Cod:","Banda","","Musica"),"green")

print '\n'

# imprime Arrays
for i in range(len(bandas)):
     print repr(str(i).zfill(5)).rjust(5), repr(bandas[i]).rjust(25), repr('>>>').rjust(5), repr(baladas[i]).rjust(25)

num =  len(baladas)
print "\n", colored("Total de ","magenta"),colored(num,"blue"), colored( "  musicas listadas","red")