Desenvolvimento Código Aberto

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")

Se você sair do interpretador Python e entrar novamente, as definições que você fez (funções e variáveis) são perdidas. Portanto, se você quer escrever um programa um pouco mais longo, é melhor usar um editor de texto para preparar a entrada de código  para o interpretador e executá-lo como um arquivo. Isto é conhecido como criação de um script.

Tal como o seu programa fica maior, você pode querer dividi-lo em vários arquivos para facilitar a manutenção. Você também pode querer usar uma função útil que você escreveu em vários programas sem copiar sua definição em cada programa.

Para suportar isto, Python tem uma maneira de colocar as definições em um arquivo e usá-los em um script ou em uma instância interativa do interpretador. Esse arquivo é chamado de módulo; definições de um módulo pode ser importadas para outros módulos ou ficar no módulo principal.

Sintaxe:

import [modulo]

from [modulo] import [função #1] , [função #2]

from [modulo] import *

Nota:

Em geral, a prática de importação * de um módulo ou pacote é desaprovado,  muitas vezes isto se faz com código mal legível. No entanto, não há problema em usá-lo para poupar a digitação em sessões interativas.

Caminho de Pesquisa de Módulos

Quando um módulo denominado [nome do modulo] é importado, o interpretador primeiro procura por um módulo integrado com esse nome. Se não for encontrado, então ele procura por um arquivo chamado [nome do modulo].py em uma lista de diretórios dadas pela variável sys.path.

sys.path é inicializada a partir destes locais:

• O diretório que contém o script de entrada (ou o diretório atual).
• PYTHONPATH (uma lista de nomes de diretório, com a mesma sintaxe que a variável PATH shell).
• O padrão é dependente da instalação.

Após a inicialização, os programas em Python podem modificar o sys.path. O diretório que contém o script que está sendo executado é colocado no início do caminho de procura, à frente do caminho da biblioteca padrão. Isto significa que os scripts neste diretório serão carregados ao invés de módulos com o mesmo nome no diretório da biblioteca. Este é um erro, a menos se a substituição for proposital.

Exemplo:

Neste simples exemplos temos dois arquivos .py localizados no mesmo diretório e vamos importar as funções de um arquivo para dentro de outro um arquivo principal:

Python

Arquivo #1

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# modulos.py
# Importa OS
import os

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

# Importa modulo
devaberto import devaberto

devaberto.msg("Menssagem enviada pela função do modulo devaberto")

Arquivo #2

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# devaberto.py
def msg(menssagem):
       print menssagem

Uma lista é um conjunto ordenado de valores, onde cada valor é identificado por um índice. Os valores que compõem uma lista são chamados elementos. Listas são similares a strings, que são conjuntos ordenados de caracteres, com a diferença que os elementos de uma lista podem possuir qualquer tipo

Listas podem ser usadas como Pilhas:

A pilha é uma estrutura de dados que armazena os dados na ordem LIFO (Last In First Out) – em português Último a Entrar Primeiro a Sair). A recuperação de dados será feita na ordem inversa de sua inserção.

Os métodos de lista tornam muito fácil de usar uma lista como uma pilha, onde o último elemento adicionado é o primeiro a ser recuperado (“LIFO”). Para adicionar um item ao topo da pilha, use append (). Para recuperar um item do topo da pilha, use pop () sem um índice explícito.

Comandos :

• Lista.append ( x ) Adicionar um item ao final da Lista.
• Lista.extend ( G ) Aumentar a Lista anexando todos os itens na Lista dada.
• Lista.insert ( i , x ) Insere um item em uma determinada posição. O primeiro argumento é o índice do elemento, o segundo argumento é o valor a ser inserido.
• Lista.remove ( x ) Retira o primeiro item da Lista cujo valor é x.
• Lista.pop ( [i]) Remove o item na posição determinada na Lista, Lista.pop( ) remove e retorna o último item da Lista.
• Lista.clear ( ) Remova todos os itens da Lista.
• Lista.index ( x ) Retorne o índice na Lista do primeiro item cujo valor é x.
• Lista.Count ( x ) Retorna o número de vezes que x aparece na Lista.
• Lista.sort ( ) Organizar os itens da Lista no lugar.
• Lista.reverse ( ) Inverte os elementos da Lista.

Exemplo:

Neste exemplo temos uma lista de bandas de rock e cantores de rock e vários exemplos de como usar este método.

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

# Importa OS
import os

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

# Listas Python

print "Listas Python\n"
print "Comandos: Insert, Append, Index, Reverse, Sort"

# Alimenta variavel
cantor= []

# Lista de Cantores

# Insere um valor = posição, valor
cantor.insert(0,"Ozzy Osbourne")

# Append acrescenta um valor
cantor.append ("Robert Plant")
cantor.append ("Axl Rose")
cantor.append ("Layne Staley")
cantor.append ("Scott Weiland")

# Lista de Bandas
banda = ["Black Sabbath","Led Zeppelin", "Gun n Roses"]
banda.append("Alice in Chains")
banda.append("Stone Temple Pilots")

# Index mostra o indice da lista
print "Robert Plant esta na posição numero: ", cantor.index("Robert Plant") print "\n"

# Função Imprime Listas
 def Lista():
         print "Bandas:"
         print banda
         print "Cantores:"
         print cantor
         print "\n"

print "Lista de Bandas e Cantores:"
Lista()

# Reverse inverte a lista
cantor.reverse()
banda.reverse()

# Imprime Lista
print "Lista Invertida" }
Lista()

# POP (indice)- Sem o indice retira o ultimo da lista (pilha)
# Last in - Firt out
banda.pop()
cantor.pop()

# Imprime Lista print "Pilha - Ultimo a entrar - Primeiro a sair"
Lista()

# Lista de Espera 
# First in - First out # Precisa importar Collections

from  collections import deque
banda = deque(banda)
cantor = deque(cantor)

banda.popleft()
cantor.popleft()

# Imprime Lista
print "Lista de espera - Primeiro a entrar - Primeiro a sair"
Lista()

Programação Orientada a objeto

Programação orientada a objetos representa o mundo real. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software.

Classes

Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Em comparação com outras linguagens de programação, mecanismo de classe do Python adiciona as classes no mínimo com uma nova sintaxe e semântica. É uma mistura de mecanismos equivalentes encontrados em C + + e Modula-3. Classes Python fornecem todas as características padrão de Programação Orientada a Objetos: o mecanismo de herança de classe permite múltiplas classes base, uma classe derivada pode substituir os métodos de sua classe base ou classes, e um método pode chamar o método de uma classe base com o mesmo nome . Os objetos podem conter quantidades arbitrárias e tipos de dados. Como é o caso para os módulos, as classes participam da natureza dinâmica do Python: eles são criados em tempo de execução, e pode ser modificado ainda mais após a criação.

As definições de classe, como definições de funções (declarações def) devem ser executados antes que tenham qualquer efeito. (Você pode conseguir colocar uma definição de classe em um galho de uma instrução if ou dentro de uma função.)

Na prática, os comandos dentro de uma definição de classe será geralmente as definições de função, mas outras declarações são permitidas, e às vezes útil – nós vamos voltar a isso mais tarde. As definições de função dentro de uma classe normalmente têm uma forma peculiar de lista de argumentos, ditada pelas convenções de chamada para métodos – de novo, isso é explicado mais tarde.

Objeto Classe

Objetos de Classe suportam dois tipos de operações: referências a atributos e instanciação.

Atributo referências usam a sintaxe padrão utilizado para todas as referências a atributos em Python: obj.name. Nomes de atributos válidos são todos os nomes que estavam no namespace da classe quando o objeto classe foi criado. Assim, se a definição de classe ficou assim:

class MinhaClasse:
"""Um simples exemplo de classe"""
i = 12345 
def f(self):
return 'Olá Mundo'

Então MinhaClasse.i e MinhaClasse.f são referências a atributos válidos, retornando um inteiro e um objeto função, respectivamente. Atributos de classe também pode ser atribuído, de modo que você pode alterar o valor de MinhaClasse.i por atribuição. __doc__ também é um atributo válido, que retorna a docstring pertencente à classe: “Um simples exemplo de classe”.

Instanciação de classe usa a notação de função. Apenas finja que o objeto classe é uma função sem parâmetros que retorna uma nova instância da classe. Por exemplo:

x = MyClass()

cria uma nova instância da classe e atribui esse objeto para a variável local x.

A operação de instanciação (“chama” um objeto de classe) cria um objeto vazio. Muitas classes criam objetos com instâncias customizadas para um estado inicial específico. Portanto, uma classe pode definir um método especial chamado __ init__ (), assim:

class Complex:
      def __init__(self, realpart, imagpart):
          self.r = realpart
          self.i = imagpart

x = Complex(3.0, -4.5)
x.r, x.i

Exemplo de Classe

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

# Importa OS
import os

# Limpa a tela
os.system("clear")
# Classe comum para os empregados
class Empregados:
     empCount = 0
     def __init__(self, nome, salario):
        self.nome = nome
        self.salario = salario
        Empregados.empCount += 1
     def displayCount(self):
        print "Total de Empregados  %d" % Empregado.empCount
     def displayEmpregados(self):
        print "Nome : ", self.nome,  ", Salario: ", self.salario

# Cria o primeiro objeto da classe empregados
emp1 = Empregados("Patricia", 2000)

# Cria o segundo objeto da classe empregados
emp2 = Empregados("Augusto", 5000)
# Cria o terceiro objeto da classe empregados
emp3 = Empregados("Marcia",3000)

# Mostra os empregados
emp1.displayEmpregados()
emp2.displayEmpregados()
emp3.displayEmpregados()
# Imprime total de empregados
print ""
print "Total de empregados %d" % Empregados.empCount