CLASES PERCISTENTES EN PYTHON

CLASES PERCISTENTES EN PYTHON
1. Introducción:
La persistencia en programación se refiere a la capacidad de un objeto de sobrevivir
más allá de la ejecución del programa que lo creó. En Python, esto se logra
comúnmente mediante el uso de bases de datos, archivos de texto, archivos binarios,
y otros sistemas de almacenamiento. La persistencia permite que los objetos se
almacenen y recuperen, conservando su estado entre las ejecuciones del programa.
2. Métodos de persistencia:
• ARCHIVOS DE TEXTO:
Los archivos de texto son una forma simple y directa de almacenar datos
en un formato legible por humanos. Este método es útil para almacenar
datos estructurados de manera sencilla, como registros de log,
configuraciones y datos de pequeño tamaño.
• BASES DE DATOS:
Las bases de datos son sistemas de almacenamiento de datos

estructurados que permiten realizar consultas y operaciones de manera
eficiente. Existen dos tipos principales de bases de datos: SQL
(relacionales) y NoSQL (no relacionales).
• ARCHIVOS BINARIOS:
Los archivos binarios permiten almacenar datos en un formato que no es

legible directamente por humanos. Son útiles para almacenar datos
complejos, como imágenes, archivos multimedia o datos estructurados
que no se prestan bien a formatos de texto.
• ARCHIVOS CSV:
Los archivos CSV (Comma-Separated Values) son una forma popular de

almacenar datos tabulares en un formato de texto plano. Cada línea de un
archivo CSV corresponde a un registro, y cada campo de un registro está
separado por una coma (u otro delimitador).
• ARCHIVOS YAML
YAML (YAML Ain't Markup Language) es un formato legible por

humanos para la serialización de datos. Es similar a JSON pero ofrece
una sintaxis más amigable y es más adecuado para la configuración y
otros datos estructurados.
3. Métodos de Persistencia en Python:
• Pickle: Una biblioteca estándar de Python que permite serializar y deserializar

objetos en un formato binario.
import pickle
# Serializar un objeto
with open('datos.pkl', 'wb') as file:
pickle.dump(objeto, file)
# Deserializar un objeto
with open('datos.pkl', 'rb') as file:
objeto = pickle.load(file)
• JSON: Una forma popular de almacenar datos estructurados en un formato de

texto.
import json
# Serializar un objeto
with open('datos.json', 'w') as file:
json.dump(objeto, file)
# Deserializar un objeto
with open('datos.json', 'r') as file:
objeto = json.load(file)
• SQLite: Una base de datos relacional ligera que se almacena en un solo

archivo.
import sqlite3
# Crear y conectar a una base de datos SQLite

conn = sqlite3.connect('datos.db')
cursor = conn.cursor()
# Crear una tabla

cursor.execute('''CREATE TABLE productos
(id INTEGER PRIMARY KEY, nombre TEXT, cantidad INTEGER,
precio REAL)''')
# Insertar datos
cursor.execute("INSERT INTO productos (nombre, cantidad, precio) VALUES
('Manzana', 50, 0.30)")
conn.commit()
# Consultar datos
cursor.execute("SELECT * FROM productos")
print(cursor.fetchall())
conn.close()
• SQLAlchemy: Un ORM (Object-Relational Mapping) que facilita la

interacción con bases de datos relacionales.
• shelve: Una biblioteca estándar de Python que proporciona una forma de

persistencia de objetos similar a Pickle, pero con un enfoque de diccionario.
import shelve
# Guardar datos en un archivo shelve

with shelve.open('datos_shelve') as shelf:
shelf['objeto'] = objeto
# Recuperar datos de un archivo shelve

with shelve.open('datos_shelve') as shelf:
objeto = shelf['objeto']
4. Ejercicio:
Descripción: Crear una aplicación que gestione un inventario de productos. Cada

producto tiene un nombre, una cantidad y un precio. Los productos deben ser
persistentes, de modo que puedan ser almacenados y recuperados de una base de
datos SQL.
5. Solución:
- Instalar SQLAlchemy:
pip install sqlalchemy
- Configurar SQLAlchemy y la base de datos:
• Definir la clase Producto.

• Configurar la base de datos SQLite.
• Crear la tabla para la clase Producto.
- Implementar operaciones CRUD:
• Crear productos.
• Leer productos.
• Actualizar productos.
• Eliminar productos.
1. Instalar SQLAlchemy
pip install sqlalchemy
2. Definir la Clase Producto y Configurar SQLAlchemy
from sqlalchemy import create_engine, Column, Integer, String, Float

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
# Crear el motor de la base de datos

engine = create_engine('sqlite:///inventario.db', echo=True)
# Crear una base de clase

Base = declarative_base()
# Definir la clase Producto

class Producto(Base):
__tablename__ = 'productos'
id = Column(Integer, primary_key=True)
nombre = Column(String)
cantidad = Column(Integer)
precio = Column(Float)
def __repr__(self):
return f"<Producto(nombre={self.nombre}, cantidad={self.cantidad},
precio={self.precio})>"
# Crear la tabla en la base de datos

Base.metadata.create_all(engine)
# Crear una sesión

Session = sessionmaker(bind=engine)
session = Session()
3. Implementar Operaciones CRUD

- Crear producto
def crear_producto(nombre, cantidad, precio):
nuevo_producto = Producto(nombre=nombre, cantidad=cantidad,
precio=precio)
session.add(nuevo_producto)
session.commit()
print(f"Producto {nombre} creado.")
# Ejemplo de uso
crear_producto('Laptop', 10, 999.99)
- Leer producto
def leer_productos():
productos = session.query(Producto).all()
for producto in productos:
print(producto)
# Ejemplo de uso
leer_productos()
- Actualizar producto:
def actualizar_producto(producto_id, nombre=None, cantidad=None,
precio=None):
producto = session.query(Producto).filter_by(id=producto_id).first()
if producto:
if nombre:
producto.nombre = nombre
if cantidad:
producto.cantidad = cantidad
if precio:
producto.precio = precio
session.commit()
print(f"Producto {producto_id} actualizado.")
else:
print(f"Producto {producto_id} no encontrado.")
# Ejemplo de uso
actualizar_producto(1, cantidad=20)
- Eliminar Producto
def eliminar_producto(producto_id):
producto = session.query(Producto).filter_by(id=producto_id).first()
if producto:
session.delete(producto)
session.commit()
print(f"Producto {producto_id} eliminado.")
else:
print(f"Producto {producto_id} no encontrado.")
# Ejemplo de uso
eliminar_producto(1)
- Ejecución
def menu():
while True:
print("\n1. Crear Producto")
print("2. Leer Productos")
print("3. Actualizar Producto")
print("4. Eliminar Producto")
print("5. Salir")
opcion = input("Seleccione una opción: ")
if opcion == '1':
nombre = input("Nombre del producto: ")
cantidad = int(input("Cantidad del producto: "))
precio = float(input("Precio del producto: "))
crear_producto(nombre, cantidad, precio)
elif opcion == '2':
leer_productos()
elif opcion == '3':
producto_id = int(input("ID del producto a actualizar: "))
nombre = input("Nuevo nombre (dejar vacío si no cambia): ")
cantidad = input("Nueva cantidad (dejar vacío si no cambia): ")
precio = input("Nuevo precio (dejar vacío si no cambia): ")
actualizar_producto(producto_id, nombre or None, int(cantidad)
if cantidad else None, float(precio) if precio else None)
elif opcion == '4':
producto_id = int(input("ID del producto a eliminar: "))
eliminar_producto(producto_id)
elif opcion == '5':
break
else:
print("Opción no válida.")
if __name__ == '__main__':
menu()
6. Conclusión
La persistencia de clases en Python es una técnica esencial para aplicaciones que

requieren que los datos sobrevivan entre ejecuciones. Utilizando herramientas como
SQLAlchemy y bases de datos como SQLite, es posible gestionar la persistencia de
objetos de manera eficiente y con relativamente poco esfuerzo. Este ejercicio demostró
cómo se puede implementar un sistema de gestión de inventario con clases persistentes en
Python, proporcionando una base sólida para aplicaciones más complejas.

CLASES PERCISTENTES EN PYTHON - Final

Cargado por

Copyright:

Formatos disponibles

CLASES PERCISTENTES EN PYTHON - Final

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

CLASES PERCISTENTES EN PYTHON - Final

Cargado por

Copyright:

Formatos disponibles

Las bases de datos son sistemas de almacenamiento de datos

Los archivos binarios permiten almacenar datos en un formato que no es

Los archivos CSV (Comma-Separated Values) son una forma popular de

YAML (YAML Ain't Markup Language) es un formato legible por

3. Métodos de Persistencia en Python:

• Pickle: Una biblioteca estándar de Python que permite serializar y deserializar

• JSON: Una forma popular de almacenar datos estructurados en un formato de

• SQLite: Una base de datos relacional ligera que se almacena en un solo

# Crear y conectar a una base de datos SQLite

# Crear una tabla

• SQLAlchemy: Un ORM (Object-Relational Mapping) que facilita la

• shelve: Una biblioteca estándar de Python que proporciona una forma de

# Guardar datos en un archivo shelve

# Recuperar datos de un archivo shelve

Descripción: Crear una aplicación que gestione un inventario de productos. Cada

pip install sqlalchemy

- Configurar SQLAlchemy y la base de datos:

• Definir la clase Producto.

- Implementar operaciones CRUD:

2. Definir la Clase Producto y Configurar SQLAlchemy

from sqlalchemy import create_engine, Column, Integer, String, Float

# Crear el motor de la base de datos

# Crear una base de clase

# Definir la clase Producto

# Crear la tabla en la base de datos

# Crear una sesión

3. Implementar Operaciones CRUD

opcion = input("Seleccione una opción: ")

La persistencia de clases en Python es una técnica esencial para aplicaciones que

También podría gustarte