Gorobytes

Definir um padrão de codificação é extremamente importante e eficaz no trabalho em equipe e legibilidade dos documentos.  Baseado no Guia de estilo para codificação em Python elaborei meu próprio estilo

IDENTAÇÃO:

4 Espaços (Não utilizar TABS e sim espaços, a maioria dos editores tem a opção de converter TABS em espaços)

LINHAS EM BRANCO:

2 Linhas em branco antes da declaração de uma função ou classe

1 Linha em branco para separar os métodos de uma classe

Linhas em branco extras podem ser usados para separa seções lógicas, grupos de funções, declarações

ENCODING:

Utilizar o UTF-8 como codificação do arquivo e na primeira linha do arquivo inserir:

# -*- coding: utf-8 -*- #

IMPORTAÇÃO DE MÓDULOS

Sempre realizar todas as importações no início do arquivo de modo que cada módulo deverá ser importado em uma linha, a não ser que se esteja especificando submódulos de um determeniado módulo. Ex:

Certo: import os                 			Errado: import sys, os

       import sys

       from subprocess import Popen, PIPE

ESPAÇOS EM BRANCO (FUNÇÕES E EXPRESSÕES)

Evitar os espaços em branco nas seguintes situações:

• Dentro de (parenteses) [colchetes] e {chaves}

  • Certo: spam(ham[1], {eggs: 2})                 Errado:  spam( ham[ 1 ], { eggs: 2 } )

• Antes de uma “,” virgula, “;” ponto e virgula e “:” dois pontos

  • Certo: if x == 4: print x, y; x, y = y, x      Errado:  if x == 4 : print x , y ; x , y = y , x

• Antes da abertura de parenteses em chamada de funções, definições e listas

  • Certo: spam(1)                                 Errado:  spam (1)

• Antes da abertura de [colchetes] de indices e {chaves} de dicionários

  • Certo: dict['key'] = list[index]               Errado:  dict ['key'] = list [index]

• Mais de um espaço em atribuições de valores

  • Certo: x = 1                                   Errado:  x       = 1

• Não utilizar espaços com em chamadas de métodos com passagem de chaves nos parâmetros e também nos dicionários

  • Certo: def complex(real, imag=0.0):            Errado: def complex(real, imag = 0.0):

Sempre utilizar espaço simples ao se trabalhar com operadores (=, +=, -=, +, -, *, <=, ==, !=, and, not, ……… )

COMENTARIOS

Devem ser identados ao mesmo nível do codigo no qual se faz pertinente e sempre será utilizado comentários de blocos iniciados por “”" e finalizados por “”" (também chamados de docstring). Ao se utilizar uma descrição breve abrir e fechar a documentação na mesma linha.

Serão comentados todas as funções que sejam públicas (exceto os get e set que são óbvios e não “possuem funcionalidades”)

CONVENÇÕES DE NOME

Nomes a evitar:

• Os seguintes caracteres: l (ele minuscúlo), O (o maiúsculo), I (i maiúsculo) como nomes de variáveis

Pacotes e módulos:

• Pacotes e Módulos devem ser curtos, com todos os caracteres em minúsculo e não utilizar underline

Classes

• UtilizarCapitalizarNomeSemExceção

Variáveis Global

• UTILIZAR_TODAS_AS_LETRAS_EM_MAIÚSCULA_E_COM_UNDERLINE

Nomes de funções e métodos

• Iniciar em minúscula para diferir das classes contudo utilizar Maiúsculas para formar mais palavras sem underline
• Métodos privados utilizam dois underlines __ no inicio do método

Variáveis, argumentos de métodos e variáveis de classes

• Sempre utilizar minusculas utilizando um underline _ separando as palavras
• Atributos privados utilizam dois underlines __ no inicio do nome

Depois de alguma teoria vamos aos exemplos que nos fazem aprender mais fácil e melhor...

Conexão com banco de dados

Criar o objeto de conexão é simples e não tem mistérios, minha dica fica com relação à codificação do banco que pode trazer problemas com os caracteres acentuados. Em minha opnião seria interessante utilizar o utf-8 e pode ser feito assim:

>>>from pyPgSQL import PgSQL

>>>con = PgSQL.connect(host="127.0.0.1",database="teste",user="postgres",password="senha",client_encoding="utf-8")

Trabalhando com dicionário ao invés de listas

O trabalho com listas é um pouco chatinho e pode gerar problemas por isso ae vai uma função que transforma a lista em dicionário

>>>def getDados(cursor):

...   indices = []

...   for i in cursor.description:

...      indices.append(i[0])

...    retorno = []

...    for row in cursor.fetchall():

...       dados = {}

...       for i in range(len(row)):

...          dados[indices[i]] = row[i]

...          retorno.append(dados)

...   return retorno

Deste modo basta chamar a função getDados passando um cursor que já executou a consulta e a mesmo retornará uma lista de dicionário onde cada dicionário corresponde a um registro e possui como indice o nome dos campos.

Para se utilizar um banco de dados no Python existem algumas maneiras dentre as quais vou especificar uma delas que é o pyPgSQL que permite se trabahlar com o PostgreSQL. Neste mini tutorial eu parto do principío que o mesmo já se encontra instalado na máquina.

Para se conectar ao banco de dados primeiramente é necessário importarmos o módulo para a aplicação da seguinte maneira:

>>>from pyPgSQL import PgSQL

O Próximo passo sera conectarmos no banco de dados…

>>>con = PgSQL.connect(host='servidor',database='banco de dados',user='usuario',password='senha')

Deste modo a variável con esta recebendo o objeto de conexão com o banco de dados e será apartir deste objeto que se dará a comunicação com o PostgreSQL. Note que a ordem dos parâmetros não é importante contando que seja atribuído os nomes dos mesmos corretamente. Abaixo segue a mesma conexão com um parâmetro adicional para setar o encoding.

>>>con = PgSQL.connect(host='servidor', atabase='banco de dados', client_encoding="charset", user='usuario', password='senha')

O segundo passo é a criação do cursor que executará os comandos SQL

>>>cur = con.cursor()

Neste caso o nome do cursor é cur, mais poderia ser qualquer outro nome e ainda poderia se ter diversos cursores para diversas consultas distintas. Após a criação do cursor passa-se a execução dos SQLs.

Consultas

As consultas são realizadas através do SQL “SELECT …. ” e se da pelo cursor criado do seguinte modo:

>>>cur.execute("SELECT * FROM table")

A partir deste ponto nosso cursor possui uma consulta e para acessar os dados utilizamos:

>>>linha1 = cur.fetchone()

Neste caso estamos atribuindo a variável linha1 o primeiro registro encontrado na busca. O tipo de retorno é uma lista de modo que precisamos saber exatamente a ordem das colunas, por isso é recomendado utilizar explicitamente o nome dos campos na busca SQL do seguinte modo:

>>>cur.execute("SELECT campo1, campo2, campo3 FROM table")

>>>linha1 = cur.fetchone()

>>>print linha1[0]  # Esta linha possui o valor do campo1

>>>print linha1[1]  # Esta linha possui o valor do campo2, e assim por diante até a quantidade de campos retornado pela busca

Quando acabarem os registros o fetchone retornará None

Outra maneira de obter os dados é buscando todos os registros de uma única vez

>>>dados = cur.fetchall()

Com isso a variável dados possui uma lista que tem em cada posição uma lista com uma linha do banco de dados. Com isto para saber quantos registro foram encontrados basta utilizar:

>>>len(dados)

e para acessar uma determinada linha:

>>>linha1 = dados[0]

A lista linha1 passa a ter o primeiro registro como se fosse chamado o método fetchone no exemplo anterior. Continuando verdadeiro a premissa de que é interessante estipular a ordem das colunas diretamente no SQL para evitar problemas.

Para se percorrer todos os registros basta colocar o resultado do fetchall como iterador do for:

>>>for linha in cur.fetchall():

...    print linha    # Isto irá imprimir uma lista com todos os dados do primeiro registro

Inserção, Alteração e Exclusão

Os método para realizar inserção e alteração é o mesmo exceto pelo fato de que estes deverão ser comitados ao finalizar todo o conjunto de instruções.

>>>cur.execute("INSERT INTO table (campo1,campo2) VALUES (valor1,'valor2')")

Isto faz uma inserção contudo se formos no banco de dados diretamente e olhar a inserção não estará lá porque a transação ainda não foi efetivada.

>>>con.commit()

Note que o commit é uma propriedade da conexao e não do cursor, agora sim se conferirmos no banco de dados os dados estarão lá. Este recurso parece ser meio ruim de inicio contudo ele garante benefícios para aplicação visto que em uma transação ou se executa tudo ou não se executa nada.

Uma outra característica do cursor é o rowcount que determina a quantidade de retorno, porém ele não é um método e sim uma propriedade do cursor da seguinte maneira:

>>>print cur.rowcount

Outro atributo do PgSQL é o description que descreve os detalhes dos campos encontrado em uma consulta da seguinte forma:

>>>print cur.description

O description é uma lista de campos que contem uma lista de detalhes de cada campo o nome dos campos por exemplo está no primeiro elemento desta lista. Exemplo que mostra o nome de todos os campos:

>>> for campo in cur.description:

...     print campo[0]

Através destes procedimentos temos uma idéia básica do pyPgSQL no próximo post descreverei algumas tarefas uteis para o mesmo…..

até ….