Capa de Datos: Logging y Postgresql Parte 2

Wiki Editing Capa de Datos en python

¡Bienvenido a la Wiki Editing Capa de Datos en python!

Descripción

Este código de ejemploCapa de Datos: Logging y Postgresql Parte 2 la clase Persona en el paquete Capa de Datos y la clase conexion en el paquete Capa de Datos.

Paquete Capa de Datos

Clase `Persona

La clase Persona es una representación de una entidad persona con atributos como id_persona, nombre, apellido y email. Estos atributos se definen en el método init de la clase, donde se les asigna los valores proporcionados como argumentos.

La clase también implementa el método str, que devuelve una representación en forma de cadena de la instancia de la clase. Este método se utiliza para obtener una descripción legible de la instancia de Persona cuando se la convierte en una cadena.

Además, la clase Persona tiene métodos getter y setter para acceder y modificar los valores de los atributos. Los métodos getter (@property) permiten obtener el valor de un atributo específico, mientras que los métodos setter (@.setter) se utilizan para asignar un nuevo valor a un atributo.

En el bloque de código que se ejecuta cuando el archivo se ejecuta directamente (if name == 'main':), se crean tres instancias de la clase Persona utilizando diferentes formas de inicialización. La primera instancia, persona1, se inicializa proporcionando valores para todos los atributos. La segunda instancia, persona2, se inicializa utilizando argumentos con nombre para especificar solo algunos atributos. La tercera instancia, persona1, se inicializa solo proporcionando un valor para el atributo id_persona.

Recuerda que para hacer uso de la función log.debug, debes importar el módulo log adecuadamente y configurarlo para el registro de mensajes de depuración.

En resumen, la clase Persona proporciona una estructura básica para representar una persona con atributos y métodos para acceder y modificar esos atributos. class Persona: def init(self, id_persona=None, nombre=None, apellido=None, email=None): self._id_persona = id_persona self._nombre = nombre self._apellido = apellido self._email = email

def __str__(self):
    return f"""
    Id Persona: {self._id_persona},
    Nombre: {self._nombre},
    Apellido: {self._apellido},
    Email: {self._email}
    """

# Métodos Getters and Setters
@property
def id_persona(self):
    return self._id_persona

@id_persona.setter
def id_persona(self, id_persona):
    self._id_persona = id_persona

@property
def nombre(self):
    return self._nombre

@nombre.setter
def nombre(self, nombre):
    self._nombre = nombre

@property
def apellido(self):
    return self._apellido

@apellido.setter
def apellido(self, apellido):
    self._apellido = apellido

@property
def email(self):
    return self._email

@email.setter
def email(self, email):
    self._email = email

if name == 'main': persona1 = Persona(1, 'Juan', 'Perez', 'jperez@gmail.com') log.debug(persona1) persona2 = Persona(nombre='Jose', apellido='Lepez', email='ljose@gmail.com') log.debug(persona2) persona1 = Persona(id_persona = 1) log.debug(persona1)

Clase `Conexion

La clase Conexion proporciona métodos para establecer una conexión a una base de datos PostgreSQL utilizando el módulo psycopg2. A continuación, se describe su funcionalidad:

Los atributos de clase _DATABASE, _USERNAME, _PASSWORD, _DB_PORT y _HOST almacenan los detalles de configuración necesarios para establecer la conexión con la base de datos PostgreSQL.

Los métodos de clase obtenerConexion() y obtenerCursor() se utilizan para obtener una instancia de conexión y un cursor, respectivamente.

El método obtenerConexion() verifica si ya existe una conexión establecida y, si no es así, intenta establecer una nueva conexión utilizando los detalles de configuración almacenados en los atributos de clase. Si ocurre algún error durante la conexión, se registra un mensaje de error y se sale del programa.

El método obtenerCursor() verifica si ya existe un cursor y, si no es así, obtiene una instancia de conexión utilizando el método obtenerConexion() y crea un nuevo cursor. Si ocurre algún error durante la obtención del cursor, se registra un mensaje de error y se sale del programa.

En el bloque de código que se ejecuta cuando el archivo se ejecuta directamente (if name == 'main':), se llama a los métodos obtenerConexion() y obtenerCursor() de la clase Conexion. Esto establece una conexión a la base de datos y obtiene un cursor para realizar operaciones en la base de datos.

Luego, mencionas "wiki", pero no proporcionas ninguna solicitud relacionada con una explicación o descripción adicional. Si tienes alguna pregunta o solicitud específica, estaré encantado de ayudarte.

class Conexion: _DATABASE = 'Test_bd' _USERNAME = 'postgres' _PASSWORD = 'Admin' _DB_PORT = '5432' _HOST = '127.0.0.1' _conexion = None _cursor = None

@classmethod
def obtenerConexion(cls):
    if cls._conexion is None:
        try:
            cls._conexion = bd.connect(host=cls._HOST,
                                       user=cls._USERNAME,
                                       password=cls._PASSWORD,
                                       port=cls._DB_PORT,
                                       database=cls._DATABASE)
            log.debug(f'Conexion Exitosa: {cls._conexion}')
            return cls._conexion
        except Exception as e:
            log.error(f'Ocurrió un error: {e}')
            sys.exit()
    else:
        return cls._conexion

@classmethod
def obtenerCursor(cls):
    if cls._cursor is None:
        try:
            cls._cursor = cls.obtenerConexion().cursor()
            log.debug(f'Se abrió corectamente el cursor: {cls._cursor}')
            return cls._cursor
        except Exception as e:
            log.error(f'Ocurrio un error: {e}')
            sys.exit()
    else:
        return cls._cursor

if name == 'main': Conexion.obtenerConexion() Conexion.obtenerCursor()

`