En el post anterior del curso de programación en Python usando Linux aprendimos a crear bases de datos y tablas y a insertar,registros y eliminarlos. Ahora  veremos como agregar registros y modificarlos.

Todo esto lo hacemos con un módulo incluído en la instalacación estandar de Python conocido como SQLite3. Este tipo de base de datos no necesita de la utilización de un servidor para funcionar ya que se guarda como un archivo en el directorio del proyecto.

Curso de programaicón en Python usando Linux.

Veamos un programa que permite a un usuario agregar registros a la base de datos existente. Aclaro que volví a restaurar el registro que había borrado en el artículo anterior.

Analicemos en detalle:
import sqlite3
Importa el módulo.
DB_NAME = "distros.db"
Asigna a la constante el nombre de nuestra base de datos.
def agregar_distro():
Define la función que nos va a permitir agregar el registro.
nombre = input("Nombre: ")
Le pide al usuario que ingrese el nombre de la distribución y lo asigna a la variable nombre.
derivada = input("Derivada de: ")
Le pide al usuario que ingrese la distribución derivada y lo asigna a la variable correspondiente:
escritorio = input("Escritorio: ")
Lo mismo que para las otras dos con el dato escritorio.
with sqlite3.connect(DB_NAME) as con:
Establece la creación con la base de datos con la que venimos trabajando.
cur = con.execute(
"INSERT INTO distros (nombre, derivada, escritorio) VALUES (?, ?, ?)",
(nombre, derivada, escritorio)
)
Esta sentencia SQL agrega una nueva fila con los valores ingresados anteriormente, los marcadores de posición, en forma de signos de pregunta, se reemplazan en el orden correcto. La variable cur guarda el resultado para tener acceso a la clave primaria que le corresponde.
print(f"Distro agregada correctamente con ID {cur.lastrowid}.")
Muestra un mensaje de éxito y la clave primaria que le coresponde.
agregar_distro()
Llama a la función que agrega el registro

Aquí vemos que se agregaron todos los campos correspondiente a la distribución Koppix con los datos ingresados manualmente. La clave primaria se agregó en forma automática.

Probemos ahora con un programa que modifique un registro.

<iframe src=»https://pastebin.com/embed_iframe/N5TMrdRJ?theme=dark» style=»border:none;width:100%»></iframe>

En este ejemplo hacemos una modificación del escritorio de la distribución LinuxMint

queremos cambiar.

El programa nos muestra los datos de la distribución que queremos cambiar y si en lugar de hacer modificaciones pulsamos Enter se quedan los datos que estaban.

En este caso hicimos el cambio del escritorio a Mate, veamos si funcionó.

Listado de todos los registros quefiguran en la base de datos de las distribuicones.

Como vemos, la modificaicón se hico sin inconvenientes;

Integrando todas las funciones:

Vamos a ver ahora un programa que integra todos los comandos que vimos hasta ahora. Sé que es tedioso repetir la explicaciones de comandos que ya vimos, pero la repetición es la base del aprendizaje.

<iframe src=»https://pastebin.com/embed_iframe/Xh5cWp5N?theme=dark» style=»border:none;width:100%»></iframe>

Vamos con el análisis detallado:

import sqlite3

Importamos el módulo para trabajar con la base de datos

DB_NAME = "distribuciones.db"

Asigna a la constante el nombre de la base de datos. Dado que esta es nueva, la va a crear.

def conectar():
return sqlite3.connect(DB_NAME)

Acá definimos la función que crea la base de datos y permitirá abrirla en próximas ejecuciones del programa. Para esto la utilizaran el resto de las funciones del programa.

def crear_tabla():
with conectar() as con:

Este comando crea la tabla usando el comando wih que permite que los cambios se incorporen y se cierre la conexión  si sale todo bien o que no se hagan cambios si hay errores.

con.execute("""
CREATE TABLE IF NOT EXISTS distros (

Evita conflictos comprobando si ya existe la tabla antes de crearla.

id_distro INTEGER PRIMARY KEY AUTOINCREMENT,

Crea la clave primaria como un número entero que se incremntará en forma automática.

nombre TEXT NOT NULL,

Asigna a nombre la condición de campo de texto de completado obligatorio.

derivada TEXT,

Asigna a derivada la condición de campo de texto pero de completado no obligatorio.

escritorio TEXT

Asigna al campo escritorio la condición de campo de texto no obligatorio e indica que es la última columna de la tabla.

)
""")

Cierra el comando SQL y deja fijo los cambios si no hay errores.

def insertar(nombre, derivada, escritorio):

Define la función que va a insertar los registros para los campos nombre, derivada y escritorio.

with conectar() as con:

Establece la conexión con la base de datos.

cur = con.execute(

Asigna a la variable cur el resultado del comando SQL.

"INSERT INTO distros (nombre, derivada, escritorio) VALUES (?, ?, ?)", (nombre, derivada, escritorio)
(nombre, derivada, escritorio)
)

Los signos de pregunta son marcadores de posición que serán reemplazados por los valores correspondientes de la tupla.  Estos valores se guardan en la varieabl cur que asignamos antes.

print(f" Distro agregada con ID {cur.lastrowid}."

Indica que se agegó la distribuicón con éxito y la clave primaria que se le asignó.

def listar():
with conectar() as con:
filas = con.execute("SELECT * FROM distros ORDER BY id_distro").fetchall()

La primera linea de este fragmento define la función que permitirá mostrar todos los registros de la base de datos. La segunda establece la conexión con esta y la tercera lista las distribuicones por orden ascendente de su clave primaria.  fetchall() devuelve los registros como una lista de tuplas.

if not filas:
print(" (No hay registros.)")
return

En caso de que la lista esté vacia avisa del problema y continúa con la ejecución del programa.

ancho = ("─" * 6, "─" * 22, "─" * 18, "─" * 18)

Esta tupla establece las líneas horizontales que se utilizarán para representar a la tabla en la terminal. Si, hay mejores formas de hacerlo, pero no es el objeto del artículo.

sep = f"┼{'┼'.join(a for a in ancho)}┼"

Tupla para armar los separadores de filas uniéndolo a las líneas horizontales de la tupla anterior.

cab = f"│{'ID':^6}│{'Nombre':^22}│{'Derivada de':^18}│{'Escritorio':^18}│"

Permite que el contenido de cada columna quede alineado.

print(f"┌{'┬'.join(a for a in ancho)}┐")

Imprime el borde superior de la tabla.

print(cab)
print(sep.replace("┼", "╪").replace("─", "═"))

Imprime la cabecera y un separador doble.

for fila in filas: id_d, nombre, derivada, escritorio = fila

Asigna por turno los 4 valores de cada tupla y los imprime.

print(f"│{id_d:^6}│{nombre:^22}│{(derivada or ''):^18}│{(escritorio or ''):^18}│")

Reemplaza el valor none que se mostraría si derivada y escritorio no se hubiera completado por una cadena vacía  y centra cada valor en su columna.

print(f"└{'┴'.join(a for a in ancho)}┘")

Imprime el borde inferior de la tabla

def buscar(id_distro):
with conectar() as con:
fila = con.execute(
"SELECT * FROM distros WHERE id_distro = ?", (id_distro,)
).fetchone()

Define la función que busca una distribución a partir de su clave primaria. En caso de que no exista da como el resultado none.

if fila:
print(f"\n ID Distro : {fila[0]}")
print(f" Nombre : {fila[1]}")
print(f" Derivada : {fila[2] or '-'}")
print(f" Escritorio: {fila[3] or '-'}")

En caso de que haya coincidencia se muestran todos los elementos dle registro.

else:
print(f" No se encontró una distro con ID {id_distro}.")

Si no se encontró la fila lo informa.

En el próximo artículo continuaremos analizando el programa

Artículo original