TypeError: module.__init__() takes at most 2 arguments (3 given)

python error

TypeError: module.__init__() takes at most 2 arguments (3 given), como su nombre indica, es un error de tipo, que generalmente hace referencia a la estructura que empleamos al importar nuestro módulos, para construir objetos en Python.

La estructura correcta al importar debería seguir esta lógica.

from Object
import ClassName

Para definir la clase podría ser

class Visitor(Object.ClassName):

Podemos también hacer esto:

from Object
import Object as Parent

Y en la definición de la clase llamar directamente a parent

class Visitor(Parent):

Errores en Python

Una estructura adecuada incluso, puede extenderse a diferentes módulos en algo como esto:

from zonas
import NomenclaturaZonas

Si deseáramos emplearlo en otro modulo podría ser: 

from zonas.NomenclaturaZonas
import NomenclaturaZonas

Si nuestro archivo es Parent1 y el classname Parent, podemos escribirlo de esta forma: 

from Parent1
import Parent

Sin embargo, si Parent1.py esta dentro de una carpeta con esta ruta

DemoFolder - > Parent1.py - > Parent(Folder).(File).(Class name)

La forma de acceder seríaa.

from Test.Parent1
import Parent

Y hasta aquí, espero que sinceramente ayudar a alguien con este post.

Subir montañas, hermana hombres

J.Martí

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í

ImportError: No module named MySQLdb

python error

ImportError: No module named MySQLdb, es un error que Python lanza cuando tiene problemas para compilar la extensión binaria, de consultas mysql.

Una solución a esto es intentar resolverlo con Python puro empleando PyMySQL

Para ello simplemente debe ser instalado de con pip.

Ver otros errores de Python

pip install pymysql 

Si estas empleando SQLAlchemy también debe cambiarse la URI, para que comience incluyendo pymysql:

SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://.....'

En dependencia de la estructura de tu código y las librerías mysql que emplea, otra solución es instalar el cliente de mysql para Python, mediante pip.

Si usas Python 3

   pip3 install mysqlclient

Si estas aun Python2

pip install mysqlclient

Tambien puedes instalar mysql-python

pip install mysql-python

Y esto es todo, espero modestamente que este post, sirva de ayuda a alguien.

Muchas gracias

El amor tiene firma de autor en las causas perdidas

R.Arjona

Error EOFError en Python

python error

El error EOFError, es un tipo de error que suele aparecer con cierta regularidad en Python y que podemos manipular con excepciones.

Se genera cuando una de las funciones integradas input () o raw_input () alcanza una condición de fin de archivo (EOF) sin leer ningún dato.

Esto ocurre cuando le hemos pedido al usuario una entrada pero no hemos proporcionado ninguna entrada en el cuadro de entrada.

Este error, a veces se experimenta al usar IDE en línea.

Podemos solucionar este problema usando try y except, para manipular la excepción.

Podemos solucionar este problema usando try y except, para manipular la excepción.

Un código como este, arrojará un error del  tipo EOFerror

Podemos manejarlo de la siguiente forma:

n = int(input())
print(n * 10)

Podemos manejarlo de la siguiente forma:

try:
    n = int(input())
    print(n * 10)
    
except EOFError as e:
    print(e)

Lee sobre otros errores de Python en este blog

Hay que sembrar un árbol, un ansia, un sueño, un hijo, porque la vida es eso , sembrar, sembrar, sembrar

J. A. Buesa

NameError: name exit is not defined

python error

En este post veremos el NameError: name exit is not defined, en  Python que cómo indica es un error de nombre, y que podemos solucionar con cierta facilidad.

Ver más errores en Python en este blog

La solución a esto es importar sys y luego importar exit.

Seria algo así:

from sys
import exit
exit()

También puede intentar esta vía

import sys
sys.exit()

Y esto es todo, debería funcionar.

Espero sinceramente que este post, sirva de ayuda  a alguien y muchas gracias.

Entrena duro y en silencio, que el éxito sea tu grito

D.

KeyError en Python

python error

En este post analizaremos cómo se origina  el KeyError, en Python y como surge esta excepción.

El KeyError se genera, cuando se accede a una clave (key) no válida dentro de un diccionario (dict).

Veamos primero la jerarquía general de  las Exceptions Class  de Python.

Resumiendo

Todas las excepciones de Python heredan de la clase BaseException o se extienden desde una clase heredada en la misma.

La jerarquía de excepciones completa de este error es:

BaseException

¿Cuándo debería usarlo?

Dado que IndexError trata con listas y KeyError trata con dictados, deberíamos explorar brevemente la diferencia entre estas dos estructuras de datos comunes en Python. Las listas de Python son similares a las matrices en la mayoría de los otros lenguajes de programación. Es una colección ordenada de objetos que se asignan en un índice numérico incremental para identificar cada elemento.

Las listas se usan comúnmente como pilas, lo que permite el comportamiento de «primero en entrar, último en salir».

Los dictados, por otro lado, se conocen como matrices asociativas en la mayoría de los otros lenguajes. Un dictado también es una colección de objetos, pero no está ordenado, y en lugar de usar índices numéricos, un dictado usa tipos de datos inmutables como claves.

Ahora te será fácil entender que siempre que veas una referencia a los pares clave: valor en Python, esto es una indicación de que la colección que contiene esos pares es un dict o diccionario.

La comprensión del error es muy simple, si creamos un diccionario e intentamos acceder a una clave que no existe, se generará un KeyError

Manejar la excepción Index Error: Index Out of Range

python error

Hablemos de cómo manejar una excepción Index Error: Index Out of Range en Python

Una solución para manejar este error de modo inesperado y prevenir que sea lanzado, es emplear un bloque try-except para encontrarlo y controlarlo.

La idea es que si ocurre una excepción durante la ejecución de nuestro codigo, la excepción quedará atrapada en el bloque except.

Ejemplo

Import sys
Try:
list =(‘a’,2,3,5,6,’b’,8)

print(lista[8])
except IndexError as e:
print(e)
print(sys.exc_info())

Una vez en este punto podrás manejar el error y lo que nos imprime.

…. no recuerdo ya el lugar de donde vengo y pueda que no exista el sitio adonde voy..

J. Sabina

Resultado incorrecto al dividir números grandes en Python3.

python error

Si te ha sucedido ya, te explico porque obtienes un resultado incorrecto al dividir números grandes en Python 3.

 Es cierto que Python 3 da errores en el resultado cuando divides dos números muy largos, empleando el símbolo /.

Esto se debe a que en Python 3.x  el símbolo / significa división de punto flotante y con números muy grandes, puede dar pequeños errores de redondeo.

Lo correcto es usar // para  la división de enteros.

Por ejemplo:

d = a // (b*c)

Espero haber ayudado a alguien.

Muchas gracias

El que siempre soñó, tiene derecho a ganar

I.Delgado

Index Error: Index Out of Range en Python

python error

El error en Python, Index Error: Index Out of Range, extiende de la clase LookupError, que se hereda de la BaseException, que viene predefinida en el lenguaje.

Dentro de la clase LookupError, se enumeran dos errores:

BaseException
  LookupError
    IndexError
      KeyError

¿Qué significa el error de Python, Index Error: Index Out of Range?

Como Python admite la indexación de elementos de lista, esta preparado para acceder a elementos iterables y operar con ellos, realizando acciones como imprimir o recorrer elementos.

El problema viene cuando se menciona un índice en su código que está fuera del rango de la lista, entonces  Python arrojará un IndexError que le indicará que el índice de la lista está fuera del rango.

Por ejemplo cuando intentamos acceder a un elemento usando un índice que está fuera del rango de esa lista, recibirá un error de  Index Error: Index Out of Range.

En en el siguiente caso, imprimir la posición (lista [8]) se refiere a una posición que no existe que no existe, ya que la primera posición de cualquier arreglo es 0, por tanto si la lista tiene 7 registros, la posición más alta es [6]

lista = (‘a’,2,3,5,6,’b’,8)
print(lista[8])

Si estas recibiendo este error basta con que te asegures que estas pidiendo una posición dentro del rango correcto.

Puedes ver mas como manejar este error aquí

…., si avanzo sígueme, si me detengo empújame, si retrocedo mátame…….

F. País

FileNotFoundError: [Errno 2] No such file or directory

python error

El error  FileNotFoundError: [Errno 2] No such file or directory, es un error común que lanza la librería OS.

En esencia este error indica que estámos intentando acceder a un archivo o carpeta que no existe, ya sea porque no está presente en la ruta de archivo en particular o porque se ha cambiado su nombre.

Normalmente verá un IOError si intenta leer o escribir en un archivo que no existe usando una instrucción open () del tipo

f = open ('nombre de archivo.txt')

Para corregirlo lo primero es  comprobar de antemano, que se está refiriendo al archivo o carpeta correcto.

Un error común es que corramos

python script.py

Cuando deberíamos llamar a la ruta correcta de esta forma

python. / script.py

Ver otros errores en Python en mi blog

Otro error que puede darse es que nuestro archivo comience con la letra n, y se confunda con una secuencia de escape; podría pasar algo asi:

path_name = "C:\name.txt " 

En este caso Python considerará \n como una secuencia de escape y nunca encontrará el archivo name.txt

Capturar el error [Errno 2] No such file or directory

Podemos capturar el error para emplearlo a conveniencia. Veamos aca algunas variantes, donde si el archivo no es encontrado manejaremos un mensaje de salida

Os

import os

path_name = "filename.txt"

if os.path.isfile(path_name):
   print("File exists")
f = open(path_name)
#Ejecutar aquí otras operaciones
f.close()

else :
   print("El archivo no existe, se encontró un error tipo IOError ")

Pathlib

from pathlib
import Path
path_name = "filename.txt"
p = Path(path_name)
if p.is_file():
   print("File exists")
f = open(path_name)
#Ejecutar aquí otras operaciones
f.close()

else :
   print("El archivo no existe, se encontró un error tipo IOError ")

Try – Except primera variante

try:
f = open("filename.txt")
#Execute other operations
f.close()
except IOError as io:
   print(io)

Try – Except segunda variante

try:
f = open("filename.txt")
#Ejecutar aquí otras operaciones
f.close()
except IOError:
   print("El archivo no existe, se encontró un error tipo IOError ")

Y hasta aquí. Espero que este post ayude a alguien.

Muchas gracias

La ira no tiene alas y es tímida, la estupidez en cambio es desenvuelta y aventurera. Por  eso volcamos nuestra ira en los que nos quieren, y nos esforzamos por complacer , a los que no importamos nada.

Y