Esta guía tiene la finalidad de mostrar de manera básica, los pasos necesarios para acceder a una

base de datos MySQL e interactuar con las tablas contenidas en ella; los procesos: de almacenamiento,
actualización y eliminación de registros, serán tratados en este documento.

Herramientas necesarias

 Sistema operativo Ubuntu (de preferencia la versión 10.10)

 Servidor LAMP (Apache, MySQL y PHP)
 Lenguaje de programación Python, versión 3
 Módulo myconnpy, instalado en la versión de Python.
“Si no tienes instalado el módulo myconnpy (el que nos permite establecer conexión con MySQL, puedes
descargarlo en esta dirección: https://launchpad.net/myconnpy”

Creación de base de datos y tabla en MySQL

Ingresa a una terminal (Aplicaciones  Accesorios  Terminal) e ingresa a MySQL

@user$mysql -u root -p
Enter password: ****

Una vez dentro del sistema gestor de bases de datos (SGBD), realiza el siguiente ejercicio:

CREATE DATABASE tecnologia;

USE tecnologia;

CREATE TABLE usuarios(

id int NOT NULL auto_increment,
codigo varchar(4) NOT NULL,
nombre varchar(20) NOT NULL,
PRIMARY KEY(id));

DESCRIBE usuarios;
+--------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| codigo | varchar(4) | NO | | NULL | |
| nombre | varchar(20) | NO | | NULL | |
+--------+-------------+------+-----+---------+----------------+

Se ha creado una base de datos llamada tecnologia (sin acento), que contiene una tabla llamada usuarios. La
tabla tiene 3 campos (id, codigo, nombre). Conociendo como está estructurado nuestro banco de datos,
procedemos a crear la aplicación ABC, con Python + myconnpy + MySQL.
 Preparación del marco de trabajo

En el directorio de tu preferencia, crea una carpeta llamada abc_py, la cual será nuestro marco de trabajo.
Dentro de este directorio, crea los siguientes sub-directorios: config, functions, view.

Directorio config:
Este directorio tendrá los archivos, que a su vez contendrán los datos o credenciales de autenticación
para ingresar a MySQL. Por el momento únicamente crearemos un archivo nuevo llamado
“constantes.py” con el siguiente script.

'''
Constantes o credenciales para conectar con mysql
'''

DB_HOST = "localhost" # Servidor

DB_USER = "root" # Nombre de usuario
DB_PASS = "root" # Clave
DB_NAME = "tecnologia" # Nombre de la base de datos

Directorio functions:
Este directorio tendrá los archivos con las funciones necesarias para: conectarse con MySQL,
insertar datos, eliminar, modificar y listar. En este momento crearemos dos archivos (dbconnect.py y
abcfunctions.py), con las funciones que ejecutaran las acciones mencionadas.

#importamos el modulo myconnpy

import mysql.connector as cnx

def dbc(hst, usr, pss, dbn):

'''
Esta función nos permite establecer conexión con MySQL
Leyenda de los argumentos solicitados
hst = Servidor
usr = usuario
pss = password
dbn = Nombre de la base de datos
'''
conn = cnx.Connect(
host = hst,
user = usr,
password = pss,
database = dbn
)

return conn

El script anterior nos permite establecer conexión con MySQL; en este punto el programador debe
conocer la utilidad que los argumentos proporcionan al instanciar una función.
def save(codigo, nombre, cnx):
'''
Esta funcion nos permite almacenar registros en la tabla
usuarios. Los argumentos necesarios son:
codigo: Valor ingresado para el campo codigo
nombre: valor ingresado para el campo nombre
cnx: objeto conexion
'''
sql = "INSERT INTO `usuarios` SET `codigo`='%s', `nombre`='%s'" % (codigo, nombre)
cur = cnx.cursor()
cur.execute(sql)

def delete(codigo, cnx):

'''
Esta funcion nos permite eliminar registros de la tabla
usuarios. Los argumentos necesarios son:
codigo: para identificar el registgro que se desea eliminar
cnx: objeto conexion
'''
sql = "DELETE FROM `usuarios` WHERE `codigo`='%s'" % (codigo)
cur = cnx.cursor()
cur.execute(sql)

def select(cnx, limit=None):

'''
Esta funcion nos permite listar resultados de la tabla
usuarios. Los argumentos necesarios son:
cnx: objeto conexion
limit (con valor none, si no desean ser listados todos los registros)
'''

query = ""

if not limit:
query = "SELECT * FROM `usuarios`"
else:
query = "SELECT * FROM `usuarios` LIMIT %s" % (limit)

cur = cnx.cursor()
cur.execute(query)

output = []

for row in cur.fetchall():

output.insert(row[0], {'codigo':row[1], 'nombre':row[2]})

return output

El script dbfunctions.py, contiene las funciones necesarias para interactuar con la base de datos:
guardar, eliminar, listar. El alumno debe definir una función que permita al usuario final actualizar
registros, tomando como argumento el código de la fila que desea modificar.
Directorio views:
Este directorio tendrá los archivos con las funciones necesarias para: Mostar las pantallas de
ingreso, eliminación, actualización y lista de registros, dichas funciones están contenidas en un
archivo llamado interaction.py

from config.constantes import *

from functions.dbconnect import dbc
from functions.abcfunctions import *
import time
import sys

def main_view():
cnx = dbc(DB_HOST, DB_USER, DB_PASS, DB_NAME)

seguir = True

while seguir:
print("Menu principal")
print("-"*30)
print("Que desea hacer?: ")
print("Listar registros: 1")
print("Guardar registros: 2")
print("Eliminar registros: 3")
eleccion = input("Eleccion: ")

if int(eleccion) == 1:
select_view(cnx)
elif int(eleccion) == 2:
save_view(cnx)
elif int(eleccion) == 3:
delete_view(cnx)

pregunta = input("Desea realizar otra accion? (s/n): ")

if pregunta != "s":
print("Adios")
time.sleep(1)
exit()
elif pregunta == "s":
continue

def save_view(cnx):
print("*" * 60)
print("Vision para almacenar registros")
print("-" * 60)
codigo = input("Codigo del usuario: ")
nombre = input("Nombre del usuario: ")
save(codigo, nombre, cnx)
time.sleep(1)
select_view(cnx)
 def delete_view(cnx):
print("*" * 60)
print("Vision para eliminar registros")
print("-" * 60)
codigo = input("Codigo del usuario: ")
delete(codigo, cnx)
time.sleep(1)
select_view(cnx)

def select_view(cnx, limit=None):

print("*" * 60)
print("Listado de registros")
print("-" * 60)
results = select(cnx, limit)
for re in results:
print('Codigo: ' + re['codigo'], end='')
print(' Nombre: ' + re['nombre'])

El programa debe definir una función que permita al usuario final interactuar con la función
actualizar.

Solo resta definir el archivo main.py, este ejecutara el sistema ABC, y lo estará contenido en la carpeta raíz de
la aplicación.

from views.interaction import *

def main():
main_view()

if __name__ == "__main__":
main()

La estructura final de nuestro marco de trabajo es la siguiente:

abc_py/
config/
constantes.py
__init__.py
functions/
abcfunctions.py
__init__.py
Views/
interaction.py
__init__.py
main.py