Mostrando entradas con la etiqueta sqlite. Mostrar todas las entradas
Mostrando entradas con la etiqueta sqlite. Mostrar todas las entradas

sábado, 10 de noviembre de 2012

Framework Python

Bueno lo prometido es deuda.. :)..

Así que pasare a mostrar mi framework.

Básicamente es un framework que sirve para hacer aplicaciones de escritorio utilizando Python, hace uso de un ORM que es SqlAlchemy y para la parte de interfaz gráfica utiliza PyQT... Cabe aclararar que esta es una primera aproximacion a lo que realmente estoy buscando... por lo cual tiene varias cosas que pulir, y el que quiera colaborar puede hacerlo.. :)..

Por ahora tiene soporte solo para las Bases de Datos:

  • SQLite
  • MySQL
Pero es fecalmente extensible a PostgreSQL.

Es importante como dije en el vídeo seguir ciertas convensiones, la principal es que el nombre del archivo con el cual se guarda el Form, sea igual al nombre del objeto form.. :). el resto practica mente queda a gusto del usuario..

En cuanto a la definición del modelo, hay unas pocas palabras reservadas por el momento:

  • tabla:  # Especifica que se debe crear una nueva tabla, con el nombre que sigue a continuación de los dos puntos
  • campo: # Especifica el nombre del campo y su tipo.
  • ucamp: # Especifica que es el ultimo campo de la tabla.
Tener en cuentas que tabla, campo y ucamp SI O SI deben estar seguidas de dos puntos ":"

En cuanto a los tipos de datos tenemos:

  • entero: Tipo de dato entero. :)
  • cadena: Tipo de dato String. Debe seguir a continuación la longitud de la cadena, en caso que no se especifique la longitud, se toma por defecto 50 caracteres.
  • real. Tipo de dato Real.
Para comprender un poco mas el uso del Framework, recomiendo ver estos dos videitos, que espero se entiendan.. :).. Si no lo logran ver bien, ponganlo en pantalla completa y mejorenle la calidad a 480p y lo verán perfectamente.

Video 1

Video 2

Para descargar el Ejecutable para Windows, pueden hacerlo desde el siguiente Link:

Descargar PyFrame

Espero que les guste, y que les sirva.. Cualquier comentario o sugerencia sera bienvenido..

Saludos y hasta la próxima.. 

lunes, 6 de febrero de 2012

ORM – Sqlalchemy (Bases de datos Python)

Desde ya hace un buen tiempo que trabajar con Bases de Datos dejo de ser algo tedioso y complicado, mucha de esta simplificación se la debemos a los ORM.

Los ORM básicamente sirven para realizar una conversión directa de objetos software a registros o tablas de una Base de datos relacional.

Supongamos que tenemos la clase Persona con los atributos, nombre, apellido y dirección.
Por otro lado deberíamos tener la tabla tPersona en la Base de datos, con los campos idPersona, apellido, nombre y dirección.

Antiguamente y a grandes razgos para guardar una persona en la Base de datos se tenia que escribir dentro del código fuente de nuestro programa, la sentencia sql que ejecutaba el insert. Así como también hacer el mapeo uno a uno de los atributos de la clase con los campos de la tabla. También se debía crear la conexión manualmente y los programas quedaban fuertemente acoplados con la Base de Datos utilizada. Es decir migrar un programa que usara MySql a uno que usara PostgreSql no era algo trivial.
Por esta razón el código quedaba “sucio” y su escalabilidad y mantenimiento se volvía complicado.

Los ORM sirven para subsanar estos inconvenientes, y hacer que el hecho de trabajar con Bases de datos relacionales sea algo mucho más llevadero.

Por ejemplo si quisiéramos escribir en la Base de datos una persona sin utilizar la potencia de un ORM, seria más o menos así...

(NO ESTA DE MAS ACLARAR QUE ESTE ES UN EJEMPLO ILUSTRATIVO Y NO FUNCIONAL…)

class Persona(object):

    def __init__(self, nombre, apellido, direccion):
        self.nombre = nombre
        self.apellido = apellido
        self.direccion = direccion

tablaPersona = Table('tPersona', self.metadata, autoload=True)

persona = Persona(“Seba”, “Bataglia”, “Dire seba”)

sentenciaSql = “Insert into tPersona (nombre, apellido, direccion) values(‘“ + persona.nombre + “’,’” + persona.apellido + “’,’”+persona.direccion+”’)”

ejecutarSql(sentenciaSql)

Ahora bien, si quisiéramos hacer lo mismo con un ORM bastaría con hacer algo así.

persona = Persona(“Seba”, “Bataglia”, “Dire seba”)
persona.Save()

Como puede observarse el código queda muchísimo más limpio. Y nos desligamos completamente de escribir Sql dentro de nuestro código fuente.

Esta es una muy muy breve introducción a lo que son los ORM. En la próxima entrega veremos como crear una aplicación con interfaz grafica por medio de PyQT y luego haremos una aplicación que sirva para persistir datos, bien basica. 

martes, 25 de octubre de 2011

Bases de Datos – Conceptos Básicos (1)

Como ya todos sabemos la forma de persistir datos suele realizarse por medio de una Base de Datos, la misma puede manejarse por medio de archivos de texto planos o por el uso de algún motor de Bases de Datos relacionales como puede ser MySQL, SQLite, PostgreSQL entre otros.
La ventaja de utilizar un motor de Base de datos es que nos ahorramos la escritura de métodos que controlen la consistencia y la integridad de los datos que vamos guardando dentro de la BD. Para los mas inexpertos que quiera hacer cosas pequeñas haré de ejemplo un programita sencillo que use una Base de Datos en un archivo de texto plano, de todas formas recomiendo ampliamente el uso de algún Motor de los nombrados con anterioridad.

Para el ejemplo de una BD en un archivo de texto abrir la consola interactiva de Python y escribir la siguiente función:

>>> def tomarDatos():
...     print 'Ingrese su nombre:'
...     nombre = raw_input()
...     print 'Ingrese su telefono:'
...     telefono = raw_input()
...     archivo = open("datoTelefonos.txt","a")
...     archivo.write(nombre + "/-/-/" + telefono + "\n")
...     archivo.close()

Si invocamos esta función como se indica a continuación:

>>> tomarDatos()
Ingrese su nombre:
pepito
Ingrese su telefono:
555-5555

Se grabara en el archivo “datoTelefonos.txt” el nombre pepito y su respectivo teléfono. Luego de cuatro corridas la Base de datos quedaría de la siguiente forma.

josema/-/-/444-4444
romina/-/-/333-3333
carlos/-/-/222-2222
pepito/-/-/555-5555

Nota: Cabe aclarar que la cadena “/-/-/” no es mas ni menos que el separador de campos, podemos usar cualquier patrón de caracteres que sepamos que no se van a repetir dentro de las cadenas para separar los campos. Luego parsearlos es sencillo.

Como puede observarse en el ejemplito se usa la línea:

archivo = open("datoTelefonos.txt","a")

Esta línea lo que hace es abrir el archivo “datoTelefonos.txt” con la opción “a” que es de append, esto quiere decir que el puntero del archivo se posiciona al final y ya queda listo para escribir datos al final del mismo.
El “open” con la opción “a” crea el archivo en caso que no exista, y lo abre y se posiciona al final en caso de que si exista. Si la opción fuera “w” el archivo se estaría abriendo con la opción de escribir, en este caso  si el archivo no existe el archivo se crea, y en caso de que si exista, el archivo se crea vació.

Para parsear los datos podemos definir esta funcion:

>>> def leerDatos():
...     print "Leyendo datos\n"
...     archivo = open("datoTelefonos.txt","r")
...     for i in archivo.readlines():
...             linea = str(i).split("/-/-/")
...             print "nombre = " + linea[0]
...             print "telefono = " + linea[1]
...     archivo.close()


La salida de invocar este método es la siguiente:

>>> leerDatos()
Leyendo datos

nombre = josema
telefono = 444-4444

nombre = romina
telefono = 333-3333

nombre = carlos
telefono = 222-2222

nombre = pepito
telefono = 555-5555

Lo que se hace en dicho método es abrir el archivo con la opción “r” READ, que seria como abrirlo como solo lectura. Luego la función “archivo.readlines()” devuelve todas las líneas del archivo en un arreglo o lista. Con el for i in archivo.readlines(): vamos iterando por las líneas una a una. En cada iteración se asigna una línea diferente en la variable “i” hasta que no queden más líneas que asignar.
Por ultimo con el método split, se parsea la línea dividiéndola según un separador pasado por parámetros, en nuestro caso se le pasa el patrón “”, el resultado es una lista, arreglo o vector que contiene todas las porciones de la cadena.

Aquí muestro otro ejemplo así queda mas claro:
>>> cadena = "esta-es-una-muestra_de-como-funciona"
>>> parseoCadena = cadena.split("-")
>>> print parseoCadena
['esta', 'es', 'una', 'muestra_de', 'como', 'funciona']