Gorobytes

Em uma "mistura" de bytes

Porque sou professor?

with 4 comments

Encontrei-me imaginando se algum dia os professores seriam substituídos por máquinas, ou se perderiam seus lugares porque as pessoas seriam capazes de comprar conhecimento em um estabelecimento, como se compra arroz e feijão. Seria algo do tipo, “Me vê uma dose de capacitação em linguagem de programação C, por favor!”, e pronto estou habilitado e capacitado sem muitos esforços para desenvolver programas em linguagem de programação C. Talvez as coisas não se tornem tão simples assim, mas quem sabe, seja possível se submeter a uma cirurgia e implantar conhecimento diretamente em alguma região do cérebro responsável pela retenção do conhecimento.

Tudo bem, talvez nada disso aconteça e os professores existam por toda a eternidade em sua árdua missão de transmitir conhecimento e extrair de cada aluno o seu melhor, contudo, não é por este motivo que me tornei professor. Embora sempre apreciei meus professores e gostei de transmitir as coisas que sei, tenho que admitir que tive uma boa oportunidade e a agarrei. Digo ainda que esta não foi a única opção que tive, por isso, ser professor foi também uma escolha.

O fato de ser jovem pesa como um fator positivo e negativo. A juventude é revolucionária, é forte, é enérgica e por isso digo que ser jovem me impulsiona a ser bom, a querer maximizar o aprendizado dos meus alunos, de ser legal e diferente. Mas ao mesmo tempo, a juventude me torna inexperiente, um pouco rebelde e com pressa. O bom é que a soma final de ser jovem, deve ser mesmo assim, positiva.

Então vamos lá… Sou professor porque quero envelhecer ao lado de pessoas jovens, quero fazer novos amigos a cada seis meses, quero ajudar as pessoas a conquistarem seus objetivos, quero transmitir o que sei. Sou professor porque acredito que uma pessoa pode mudar sua vida através do conhecimento, porque é motivador ver o brilho do entendimento brilhar no olhar de uma pessoa. Sou professor porque gosto de ensinar e de aprender, gosto de estudar, gosto de me superar. Sou professor porque não gosto de rotina, porque gosto de pesquisa, porque quero me superar todos os dias.

Fiz este texto primeiramente para encontrar meus motivos e torná-los claros para mim mesmo. Tenho me dedicado para melhorar minhas aulas, tenho buscado entender melhor meus alunos, encontrar meios para mostrar para os alunos que o conteúdo pode ser entendido. Busco ser melhor porque não quero ser apenas mais um professor, quero ser um bom professor e deste modo vou tentando fazer a minha parte.

Contudo agora é a minha vez, e você porque é aluno?

Written by rivolli

1 setembro, 2009 at 7:51 pm

Publicado em escolar, reflexao

Onde estão os meus óculos

with 2 comments

Quando acordei me percebi sem eles, por um momento achei que não havia acordado ainda.

Mas pensei por um segundo. Pensei em muitas coisas. Pensei até que cabe tanto pensamento em um segundo, que por um segundo eu resolvi só pensar.

Pensei que posso fechar meus olhos e esquecer os óculos, que é até melhor não olhar nem pra trás nem pra frente, apenas andar.

Andar, andar e pensar.

O caminho pode ser longo e por isso pode ser bom fechar os olhos e parar de controlar tantas coisas. Apenas deixar me ir, com força, vontade e coragem. Os planos existem e não basta escrevê-los em papel. É necessário cumpri-los mesmo com tantas saudades e vontades.

Paro de pensar, abro os olhos e vejo que realmente perdi os meus óculos. Perder é sempre difícil, perder duas vezes é ainda mais. Mas nem por isso vou parar, vou apenas fechar os meus olhos e caminhar.

Adriano Rívolli, é professor e programador (as vezes viaja, como agora….)

Written by rivolli

18 março, 2009 at 7:15 pm

Publicado em geral, reflexao

mod_python – Como descobrir o ip, navegador e so do usuário ….

with 4 comments

Para conseguir visualizar os dados enviados pelo header basta utilizar um parâmetro do objeto req da seguinte forma:

req.write(str(req.subprocess_env))

Ao se fazer isso aparecerá na tela somente alguns dados. Para se ter uma lista mais completa de dados primeiramente devemos chamar a função add_common_vars() do seguinte modo:

req.add_common_vars()

req.write(str(req.subprocess_env))

Com isso será possível notar uma lista mais rica em dados. Contudo os mais interessantes ao meu ver são:

req.subprocess_env['HTTP_USER_AGENT']  – Contém os dados do navegador, e sistema operacional utilizado pelo usuario

req.subprocess_env['REMOTE_ADDR']  – Ip do usuário

req.subprocess_env['REMOTE_ADDR'] – Query dos dados passados por GET

req.subprocess_env['SCRIPT_NAME'] – qual o caminho apartir da raiz do domínio em que esta o arquivo chamado

req.subprocess_env['SERVER_ADDR'] – Ip do servidor

req.subprocess_env['HTTP_HOST'] – Domínio do servidor

Existem mais dados que se analizados são facilmente identificados… a todos um abraço….

Written by rivolli

29 agosto, 2007 at 11:13 am

Publicado em geral

Como utilizar o MVC

with one comment

O padrão MVC (Model View Controler) que traduzido siginifica uma camada de Modelo, Visão e Controle que também é conhecido por representar uma arquitetura de software, é bastante divulgado e comentado, entretanto ao se tentar implementar um software com esse padrão muitas dúvidas surgem e na prática ficamos com a teoria e não sabemos como efetivamente implementar esse padrão.

Após ler diversos materiais sobre o assunto gostaria de fazer um apanhado geral do que encontrei na tentativa de esclarecer o processo de desenvolvimento em 3 camadas chamado de MVC.

As funções das camadas são:

M – MODEL: Encapsula o núcleo da aplicação e a abstração dos dados

V – VIEW: Obtém os dados de um modelo e apresenta para o usuário

C – CONTROLLER: Recebe as requisições e as encaminha para processamento

Model

Esta camada deve ser independente e funcionar de forma exclusiva. Sua principal característica é fazer a abstração dos dados e dos mecanismos de armazenamento. Seu funcionamento ocorre de forma passiva, ou seja, não possui conhecimento dos níveis superior.

View

Camada de apresentação de dados. Representa a saída e fornece o mecanismo de entrada dos dados. Esta camada pode acessar diretamente o modelo para consultas (através dos métodos que esse oferece), contudo, não pode alterar o modelo.

Controller

São responsáveis pelas chamadas de métodos que alteram o modelo, sendo responsável por comunicar a camada de visão para se atualizar. Algo importante a se destacar é que esta camada não é uma ponte entre as outras duas camadas. Afinal ambos (Controller e View) tem a oportunidade de acessar o modelo.

Relacionamentos entre as camadas

  • View e Controller:

Na definição do MVC as duas camadas são extremamente dependentes, de modo que o Controller é o mecanismo que o view possui para salvar os dados e os atualizar.

  • View e Model:

O View depende do Model e as alterações no modelo necessitam que a visão seja alterada.

  • Controller e Model:

O Controller depende do Model e as alterações no modelo são realizadas por esta camada.

Written by rivolli

13 agosto, 2007 at 11:10 pm

Padrão de codificação em python

leave a comment »

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

	

Written by rivolli

12 julho, 2007 at 11:30 am

Publicado em python

PyPgSQL exemplos práticos…

leave a comment »

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.

Written by rivolli

11 julho, 2007 at 1:00 pm

Publicado em database, postgresql, pypgsql, python

Tutorial básico sobre pyPgSQL

with one comment

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é ….

Written by rivolli

11 julho, 2007 at 12:14 pm

Publicado em database, postgresql, pypgsql, python

Seguir

Obtenha todo post novo entregue na sua caixa de entrada.