当我从数据库中选择时，对象不可编辑

Question

我正在学习python上带有池和游标的数据库，我一直在对数据库进行选择以返回我的信息

当我试图获取信息并将其放在列表中进行迭代时，Python会抛出一个错误，例如TypeError:“Usuario”对象不可编辑。以下是DAO的代码：

from usuario import Usuario
from logger_base import logger
from cursor import CursorPool

class UsuarioDao:
    __SELECCIONAR = 'SELECT * FROM usuarios ORDER BY id_usuario'
    __INSERTAR = 'INSERT INTO usuarios(username, password) VALUES(%s,%s)'
    __ACTUALIZAR = 'UPDATE usuarios SET username=%s, password=%s WHERE id_usuario=%s'
    __ELIMINAR = 'DELETE FROM usuarios where id_usuario=%s'
    
    @classmethod
    def seleccionar(cls):
        with CursorPool() as cursor:
            logger.debug(cursor.mogrify(cls.__SELECCIONAR))
            cursor.execute(cls.__SELECCIONAR)
            registros = cursor.fetchall()
            usuarios = []
            for registro in registros:
                usuarios = Usuario(registro[0], registro[1], registro[2])
            return usuarios
        
    @classmethod
    def insertar(cls, usuario):
        with CursorPool() as cursor:
            valores = (usuario.get_username(), usuario.get_password())
            logger.debug(cursor.mogrify(cls.__INSERTAR))
            cursor.execute(cls.__INSERTAR, valores)
            return cursor.rowcount

if __name__ == '__main__':

    #Insertamos un nuevo registro
    #usuario = Usuario(username='Ramon', password='542')
    #usuario_insertado = UsuarioDao.insertar(usuario)
    #logger.debug(f'usuario añadido: {usuario_insertado}')

    usuarios = UsuarioDao.seleccionar()
    for usuario in usuarios:
        logger.debug(usuario)

我的光标和连接代码如下：

from conexion import Conexion
from logger_base import logger

class CursorPool:
    def __init__(self):
        self.__conn = None
        self.__cursor = None
    
    #Incio de with
    def __enter__(self):
        logger.debug(f'Inicio de with metodo __enter__ {self.__conn}')
        self.__conn = Conexion.obtenerConexion()
        self.__cursor = self.__conn.cursor()
        return self.__cursor
    
    def __exit__(self, exception_type, exception_value, exception_traceback):
        logger.debug('Se ejecuta método __exit__()')
        if exception_value:
            self.__conn.rollback()
            logger.debug(f'Ocurrió una excepción: {exception_value}')
        else:
            self.__conn.commit()
            logger.debug('Commit de la transacción')
        #Cerramos el cursor
        self.__cursor.close()
        #Regresamos la conexion al pool
        Conexion.liberarConexion(self.__conn)

from logger_base import logger
from psycopg2 import pool
import sys

class Conexion:
    __DATABASE = 'lab_final'
    __USERNAME = 'postgres'
    __PASSWORD = 'admin'
    __DB_PORT = '5432'
    __HOST = '127.0.0.1'
    __MIN_CON = 1
    __MAX_CON = 5
    __pool = None
    
    @classmethod
    def obtenerPool(cls):
        if cls.__pool is None:
            try:
                cls.__pool = pool.SimpleConnectionPool(
                                                    cls.__MIN_CON,
                                                    cls.__MAX_CON,
                                                    host = cls.__HOST,
                                                    user=cls.__USERNAME,
                                                    password=cls.__PASSWORD,
                                                    port=cls.__DB_PORT,
                                                    database=cls.__DATABASE)
                logger.debug(f'Creacion del pool exitosa {cls.__pool}')
                return cls.__pool
            except Exception as e:
                logger.error(f'Error al crear el pool de conexiones:{e}')
                sys.exit()
        else:
            return cls.__pool
        
    @classmethod
    def obtenerConexion(cls):
        #Obtener conexion del pool
        conexion = cls.obtenerPool().getconn()
        logger.debug(f'Conexion obtenida del pool: {conexion}')
        return conexion
    
    @classmethod
    def liberarConexion(cls, conexion):
        #Regresar el objeto de conexion al pool
        cls.obtenerPool().putconn(conexion)
        logger.debug(f'Regresamos la conexion al pool: {conexion}')
        logger.debug(f'Estado del pool: {cls.__pool}')
    
    @classmethod
    def cerrarConexiones(cls):
        #Cerrar el pool y todas sus conexiones
        cls.obtenerPool().closeall()

我的用户对象是一个简单的对象，有id、用户名和密码

from logger_base import logger

class Usuario:
    def __init__(self, id_usuario = None, username = None, password = None):
        self.__id_usuario = id_usuario
        self.__username = username
        self.__password = password
    
    def __str__(self):
        return (f'ID usuario: {self.__id_usuario}, Username: {self.__username}, Password: {self.__password}')
            
    def get_id_usuario(self):
        return self.__id_usuario
    
    def set_id_usuario(self, id_usuario):
        self.__id_usuario = id_usuario
        
    def get_username(self):
        return self.__username
    
    def set_username(self, username):
        self.__username = username
    
    def get_password(self):
        return self.__password
    
    def set_password(self, password):
        self.__password = password

首先，我认为可能的错误是，我的数据库中只有一个用户，python没有列出一个列表，但我有多个用户

Answer 1

您试图在此处列出usuario：

usuarios = []

但是你在这里用一个对象覆盖它：

usuarios = Usuario(registro[0], registro[1], registro[2])

因此，此方法只返回一个对象

您想要的是.append()将对象添加到列表中：

usuarios.append(Usuario(registro[0], registro[1], registro[2]))

它将返回可以迭代的Usuario对象列表