NameError en Python

python error

El error  NameError en Python   ocurre cuando el intérprete CPython no reconoce un nombre de objeto local o global que se haya proporcionado en el código fuente de Python.

Este error hereda de Exception que a su vez se extiende  BaseException

BaseException  -> Exception -> NameError

Emplearemos este código de ejemplo:

import dis


from gw_utility.logging import Logging


def main():
    try:
        # Create Auto.
        auto = Auto("Chevrolet, "Bell Air", 50, datetime.date(1956))

        # Log auto object.
        Logging.line_separator("log_object(auto)", 60)
        log_object(auto)

        # Log invalid object.
        Logging.line_separator("log_invalid_object(auto)", 60)
        log_invalid_object(auto)

        # Disassemble both log_ functions.
        Logging.line_separator("DISASSEMBLY OF log_object()", 60)
        disassemble_object(log_object)

        Logging.line_separator("DISASSEMBLY OF log_invalid_object()", 60)
        disassemble_object(log_invalid_object)
    except NameError as error:
        # Salida esperada es NameErrors.
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada es una Excepcion.
        Logging.log_exception(exception, False)


def log_object(value):
    """Registro del valor de parametro pasado a consola.

    :param value: Value to be logged.
    :return: None
    """
    try:
        Logging.log(value)
    except NameError as error:
        # Salida esperada es NameErrors
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada es una Excepcion.
        Logging.log_exception(exception, False)


def log_invalid_object(value):
    """Intenta  registrar el objeto invalido  valu en la consola

    :param value: Value intended to be logged, but which is instead ignored.
    :return: None
    """
    try:
        Logging.log(valu)
    except NameError as error:
        # Salida esperada es NameErrors
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada es una Excepcion.
        Logging.log_exception(exception, False)


def disassemble_object(value):
    """salida desensamblada del objeto pasado.

    :param value: Object to be disassembled.
    :return: None
    """
    dis.dis(value)


if __name__ == "__main__":
    main()

# auto.py
import datetime


class Auto:
    marca: str
    modelo: int
    potencia: str
    año de fabricación: datetime.date
    potencia: str

    def __eq__(self, other):
        """Determina si el objeto pasado, es equivalente al objeto actual"""
        return self.__dict__ == other.__dict__

    def __init__(self,
                 marca: str = None,
                 modelo: str = None,
                 potencia: int = None,
                 año_fabricacion: datetime.date = None):
        """Inicializa una instanci de Auto .

        :param marca: Nombre de la marca.
        :param modelo: Modelo.
        :param potencia: Potencia en HP.
        :param año_fabricacion: Año de fabricación.
        """
        self.marca = marca
        self.modelo = modelo
        self.potencia = potencia
        self.año_fabricacion = año_fabricacion

    def __getattr__(self, marca: str):
        """Devuelve el atributo pasado comparandolo con marca."""
        # Get internal dict value matching marca.
        value = self.__dict__.get(marca)
        if not value:
            # Lanza AttributeError si el atributo no se encuentra.
            raise AttributeError(f'{self.__class__.__marca__}.{marca} is invalid.')
        # Devuelve el valor del atributo
        return value

    def __len__(self):
        """Devuelve la longitud de la marca."""
        return len(self.title)

    def __str__(self):
        """Retorna una cadena formateada que representa a SAuto."""
        año_fabricacion = '' if self.año_fabricacion is None else f', fabricado en {self.año_fabricacion.__format__(" %Y")}'
        potencia = '' if self.potencia is None else f' con {self.potencia}  de fuerza'
        return f'\'{self.modelo}\'  de la marca {self.marca} con {potencia} HP, fabricado en {año_fabricacion}.'

Desglosaremos ahora el código para explicar el error

Comenzaremos con  parte del  código de ejemplo, que vimos antes escrito  en Python normal; después de lo cual veremos cómo podemos desensamblar este código en el código de bytes que CPython realmente lee e interpreta.

log_object y log_invalid_object

Vamos a emplear dos funciones, que  Python posee para esto log_object(value)  y log_invalid_object(value):

def log_object(value):
    """Registra los valores pasados al parametro en consola.

    :param value: Valor a registrar.
    :return: None
    """
    try:
        Logging.log(value)
    except NameError as error:
        # Salida esperada NameErrors.
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada Exceptions.
        Logging.log_exception(exception, False)


def log_invalid_object(value):
    """Intenta registrar objetos no validos(value) en consola 

    :param value: Valor que se ha intentado registrar, pero que en realidad se ha ignorado 
    :return: None
    """
    try:
        Logging.log(valu)
    except NameError as error:
        # Salida esperada NameErrors.
        Logging.log_exception(error)
    except Exception as exception:
        # Salida inesperada Exceptions.
        Logging.log_exception(exception, False)

Todo el código en ambas funciones se centra en el manejo de errores.

La funcionalidad principal tiene lugar en la línea: Logging.log (valor) y Logging.log (valu), respectivamente.

En esencia, estas dos funciones lo que hacen es registrar el contenido del parámetro de valor pasado en la consola. Sin embargo, en el caso de log_invalid_object () tenemos un leve error tipográfico de valu en lugar de value.

Creemos una instancia del objeto Auto  y  luego la pasaré a ambas funciones:

# Creando Auto.
auto = Auto("Chevreolet", "Bell air", 300hp, datetime.date(1956))
# Log Auto object.
Logging.line_separator("log_object(auto)", 60)
log_object(auto)
 
# Log invalid object.
Logging.line_separator("log_invalid_object(auto)", 60)
log_invalid_object(auto)

La ejecución de este código produce una salida del objeto Auto esperada, seguida de un NameError porque nuestro error tipográfico de valu no es un nombre reconocido.

--------------------- log_object(auto) ---------------------
'Bellair' de la marca Chevrolet con 30 HP, fabricado en 1956.
{self.modelo}\'  de la marca {self.marca} con {potencia} HP, fabricado en {año_fabricacion}.'
 
----------------- log_invalid_object(auto) -----------------
[EXPECTED] NameError: name 'valu' is not defined

Si aplicaramos el metodo    dis, que es un modulo desensamblador integrado en Python, lo cual le permite es un lenguaje poderoso que nos permite mirar profundizar y ver el código de bytes real que cada una de estas funciones log_  que se generan para el intérprete CPython.

Al pasar una referencia de función al método dis.dis (), se nos proporciona una salida completa del código de bytes desensamblado que CPython interpreta durante la ejecución.

Nuestra función local  disassemble_object(value), funciona como una pequeña envoltura para este propósito:

def disassemble_object(value):
    """Salida con el objeto desensamblado pasado.

    :param value: Object to be disassembled.
    :return: None
    """
    dis.dis(value)

Para ver el bytecode de la función log_object (value) ejecutemos el código:

# Disassemble both log_ functions.
Logging.line_separator("DISASSEMBLY OF log_object()", 60)
disassemble_object(log_object)

This produces the following output:

--------------- DISASSEMBLY OF log_object() ----------------
 41           0 SETUP_EXCEPT            14 (to 16)

 42           2 LOAD_GLOBAL              0 (Logging)
              4 LOAD_ATTR                1 (log)
              6 LOAD_FAST                0 (value)
              8 CALL_FUNCTION            1
             10 POP_TOP
             12 POP_BLOCK
             14 JUMP_FORWARD            88 (to 104)

 43     >>   16 DUP_TOP
             18 LOAD_GLOBAL              2 (NameError)
             20 COMPARE_OP              10 (exception match)
             22 POP_JUMP_IF_FALSE       58
             24 POP_TOP
             26 STORE_FAST               1 (error)
             28 POP_TOP
             30 SETUP_FINALLY           16 (to 48)

 45          32 LOAD_GLOBAL              0 (Logging)
             34 LOAD_ATTR                3 (log_exception)
             36 LOAD_FAST                1 (error)
             38 CALL_FUNCTION            1
             40 POP_TOP
             42 POP_BLOCK
             44 POP_EXCEPT
             46 LOAD_CONST               1 (None)
        >>   48 LOAD_CONST               1 (None)
             50 STORE_FAST               1 (error)
             52 DELETE_FAST              1 (error)
             54 END_FINALLY
             56 JUMP_FORWARD            46 (to 104)

 46     >>   58 DUP_TOP
             60 LOAD_GLOBAL              4 (Exception)
             62 COMPARE_OP              10 (exception match)
             64 POP_JUMP_IF_FALSE      102
             66 POP_TOP
             68 STORE_FAST               2 (exception)
             70 POP_TOP
             72 SETUP_FINALLY           18 (to 92)

 48          74 LOAD_GLOBAL              0 (Logging)
             76 LOAD_ATTR                3 (log_exception)
             78 LOAD_FAST                2 (exception)
             80 LOAD_CONST               2 (False)
             82 CALL_FUNCTION            2
             84 POP_TOP
             86 POP_BLOCK
             88 POP_EXCEPT
             90 LOAD_CONST               1 (None)
        >>   92 LOAD_CONST               1 (None)
             94 STORE_FAST               2 (exception)
             96 DELETE_FAST              2 (exception)
             98 END_FINALLY
            100 JUMP_FORWARD             2 (to 104)
        >>  102 END_FINALLY
        >>  104 LOAD_CONST               1 (None)
            106 RETURN_VALUE

Esto puede parecer un poco abrumador al principio, pero estos datos en realidad son bastante fáciles de interpretar con un poco de conocimiento sobre lo que estamos viendo en cada columna. La primera columna (por ejemplo, 41, 42, 43… 48) es el número de línea real en la gama de origen para el conjunto de instrucciones correspondiente.

Por lo tanto, podemos ver que todas las siguientes instrucciones

42           2 LOAD_GLOBAL              0 (Logging)
              4 LOAD_ATTR                1 (log)
              6 LOAD_FAST                0 (value)
              8 CALL_FUNCTION            1
             10 POP_TOP
             12 POP_BLOCK
             14 JUMP_FORWARD            88 (to 104)

 Todos se generaron a partir de una sola línea de código fuente (# 42):

La columna con múltiplos de dos (0, 2, 4, etc.) es la dirección de memoria en el código de bytes subyacente para la instrucción dada. Python moderno almacena instrucciones usando dos bytes de datos, de ahí los múltiplos de dos.

La siguiente columna contiene el nombre de operación (es decir, instrucción) que debe ejecutarse, todo lo cual se puede encontrar en la documentación oficial.

La columna posterior contiene los argumentos, si corresponde, que utilizará cada instrucción en particular.

La columna final proporciona una versión amigable para los humanos de la instrucción, por lo que podemos visualizar mejor cómo la instrucción del código de bytes se correlaciona con el código fuente.

Por lo tanto, echemos un vistazo al código fuente de una sola línea 42 de Logging.log (value) y el conjunto de instrucciones de bytecode generado para ver qué está pasando:

42           2 LOAD_GLOBAL              0 (Logging)
              4 LOAD_ATTR                1 (log)
              6 LOAD_FAST                0 (value)
              8 CALL_FUNCTION            1
             10 POP_TOP
             12 POP_BLOCK
             14 JUMP_FORWARD            88 (to 104)

Comienza con LOAD_GLOBAL para cargar el nombre global Logging en la pila.

Luego carga el atributo de registro en la parte superior de la pila (TOS).

LOAD_FAST empuja una referencia a una variable local llamada value en la pila y a continuación, CALL_FUNCTION llama a la función en la pila de argumentos 1, que es el método de registro que se agregó dos instrucciones antes.

POP_TOP elimina el elemento más reciente agregado a la pila, que es el objeto de valor local.

Cada marco de ejecución contiene una pila de bloques de código, que son las agrupaciones lógicas que vemos y creamos al escribir el código fuente que está agrupado localmente.

Por ejemplo, un bucle anidado o, en este caso, un bloque try-except, está contenido dentro de un bloque de código separado en la pila.

Dado que la siguiente instrucción a la que estamos saltando con JUMP_FORWARD 88 está saliendo del final del bloque try que se encuentra en nuestro código fuente, POP_BLOCK se usa para eliminar el bloque superior (actual) de la pila de bloques de código.

Veamos en qué se diferencia este bytecode compilado para log_object, de la función log_invalid_object ligeramente modificada:

Logging.line_separator("DISASSEMBLY OF log_invalid_object()", 60)
disassemble_object(log_invalid_object)

Ignoraremos la mayoría del bytecode producido aquí, ya que es idéntico al producido por log_object, pero también tenemos el conjunto de instrucciones de la misma línea de código fuente Logging.log (valu) correspondiente que examinamos antes:

58           2 LOAD_GLOBAL              0 (Logging)
              4 LOAD_ATTR                1 (log)
              6 LOAD_GLOBAL              2 (valu)
              8 CALL_FUNCTION            1
             10 POP_TOP
             12 POP_BLOCK
             14 JUMP_FORWARD            88 (to 104)

Todo se ve exactamente igual que antes, con dos excepciones: el número de línea 58 es obviamente diferente, ya que estamos compilando una línea diferente de código fuente.

La segunda diferencia es que la tercera instrucción, cambió de LOAD_FAST 0 (value) a LOAD_GLOBAL2(valu).

¿Por qué sucedió esto?. Pues porque el compilador no puede conciliar un objeto local llamado valu, ya que el parámetro local real pasado a la función es value.

Por lo tanto, el compilador asume que valu es un nombre global e intenta cargarlo a través de LOAD_GLOBAL, y como sabemos al ejecutar la función log_invalid_object, el intérprete de CPython no será capaz de ubicar un objeto llamado valu durante la ejecución, por lo que se genera un NameError para indicarlo.

.. y todo como el diamante, antes de luz , es carbón.

J. Martí