Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· openaiHugging Face Suzhen/CodeChat

este código que escribo sirve para importar qx de diferentes tablas para después usarlas…

  1. User

    este código que escribo sirve para importar qx de diferentes tablas para después usarlas y calcular para cada una diferentes variables (siendo alguna de las tablas generacionales) PRIMERO----> EJECUTAMOS LA LECTURA DE LAS lx DE DIFERENTES TABLAS import pandas as pd

    class BiometricTableImporter: def init(self, file_path): self.file_path = file_path

    def import_table(self, sheet_name, usecols, skiprows, nrows):
        df = pd.read_excel(
            self.file_path,
            sheet_name=sheet_name,
            usecols=usecols,
            skiprows=skiprows,
            nrows=nrows
        )
        return df
    

    if name == "main": file_path = r"F:\1Assegurances\MUTUALITATS\MANUAL\2 NORMATIVA\5.-Taules actuarials\3bis.-Anexos Resolución de 17 de diciembre de 2020.xlsx"

    importer = BiometricTableImporter(file_path)
    
    # Parámetros para la primera tabla
    sheet_name1 = "Anexo 2.1"
    usecols1 = "C: E"
    skiprows1 = 7
    nrows1 = 121
    PERF2020_COL_1 = importer.import_table(sheet_name1, usecols1, skiprows1, nrows1)
    
    # Parámetros para la segunda tabla
    sheet_name2 = "Anexo 2.1"
    usecols2 = "G: I"
    skiprows2 = 7
    nrows2 = 121
    PERM2020_COL_1 = importer.import_table(sheet_name2, usecols2, skiprows2, nrows2)
    
    # Parámetros para la segunda tabla
    sheet_name3 = "Anexo 2.1"
    usecols3 = "M: O"
    skiprows3 = 7
    nrows3 = 121
    PERF2020_IND_1 = importer.import_table(sheet_name3, usecols3, skiprows3, nrows3)
    
    # Parámetros para la segunda tabla
    sheet_name4= "Anexo 2.1"
    usecols4 = "Q: S"
    skiprows4 = 7
    nrows4 = 121
    PERM2020_IND_1 = importer.import_table(sheet_name4, usecols4, skiprows4, nrows4)
    
    # Parámetros para la segunda tabla
    sheet_name5 = "Anexo 1.1"
    usecols5 = "C: D"
    skiprows5 = 7
    nrows5 = 121
    PERF2020_COL_2 = importer.import_table(sheet_name5, usecols5, skiprows5, nrows5)
    
    # Parámetros para la segunda tabla
    sheet_name6 = "Anexo 1.1"
    usecols6 = "E: F"
    skiprows6 = 7
    nrows6 = 121
    PERM2020_COL_2 = importer.import_table(sheet_name6, usecols6, skiprows6, nrows6)
    
    # Parámetros para la segunda tabla
    sheet_name7 = "Anexo 1.1"
    usecols7 = "H: I"
    skiprows7 = 7
    nrows7 = 121
    PERF2020_IND_2 = importer.import_table(sheet_name7, usecols7, skiprows7, nrows7)
    
    # Parámetros para la segunda tabla
    sheet_name8 = "Anexo 1.1"
    usecols8 = "J: K"
    skiprows8 = 7
    nrows8 = 121
    PERM2020_IND_2 = importer.import_table(sheet_name8, usecols8, skiprows8, nrows8)
    
    # Parámetros para la segunda tabla
    sheet_name9 = "Anexo 1.2 y Anexo 1.3"
    usecols9 = "B: B"
    skiprows9 = 7
    nrows9 = 121
    PASEF2020_GEN_2 = importer.import_table(sheet_name9, usecols9, skiprows9, nrows9)
    
    # Parámetros para la segunda tabla
    sheet_name10 = "Anexo 1.2 y Anexo 1.3"
    usecols10 = "C: C"
    skiprows10 = 7
    nrows10 = 121
    PASEM2020_GEN_2 = importer.import_table(sheet_name10, usecols10, skiprows10, nrows10)
    
    # Parámetros para la segunda tabla
    sheet_name11 = "Anexo 1.2 y Anexo 1.3"
    usecols11 = "E: E"
    skiprows11 = 7
    nrows11 = 121
    PASEF2020_DEC_2 = importer.import_table(sheet_name11, usecols11, skiprows11, nrows11)
    
    # Parámetros para la segunda tabla
    sheet_name12 = "Anexo 1.2 y Anexo 1.3"
    usecols12 = "F: F"
    skiprows12 = 7
    nrows12 = 121
    PASEM2020_DEC_2 = importer.import_table(sheet_name12, usecols12, skiprows12, nrows12)
    
    # Parámetros para la segunda tabla
    sheet_name13 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols13 = "B: B"
    skiprows13 = 7
    nrows13 = 121
    PASEF_REL_1 = importer.import_table(sheet_name13, usecols13, skiprows13, nrows13)
    
    # Parámetros para la segunda tabla
    sheet_name14 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols14 = "C: C"
    skiprows14 = 7
    nrows14 = 121
    PASEM_REL_1 = importer.import_table(sheet_name14, usecols14, skiprows14, nrows14)
    
    # Parámetros para la segunda tabla
    sheet_name15 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols15 = "E: E"
    skiprows15 = 7
    nrows15 = 121
    PASEF_NOREL_1 = importer.import_table(sheet_name15, usecols15, skiprows15, nrows15)
    
    # Parámetros para la segunda tabla
    sheet_name16 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols16 = "F: F"
    skiprows16 = 7
    nrows16 = 121
    PASEM_NOREL_1 = importer.import_table(sheet_name16, usecols16, skiprows16, nrows16)
    
    # Parámetros para la segunda tabla
    sheet_name17 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols17 = "H: H"
    skiprows17 = 7
    nrows17 = 121
    PASEF_DEC_1 = importer.import_table(sheet_name17, usecols17, skiprows17, nrows17)
    
    # Parámetros para la segunda tabla
    sheet_name18 = "Anexo 2.2,Anexo 2.3 y Anexo 2.4"
    usecols18 = "I: I"
    skiprows18 = 7
    nrows18 = 121
    PASEM_DEC_1 = importer.import_table(sheet_name18, usecols18, skiprows18, nrows18)
    # Puedes continuar creando instancias para importar más tablas según sea necesario…
    
    # Y luego hacer algo con las tablas, como imprimir o procesarlas
    print(PERM2020_COL_1)
    print(PERF2020_COL_1)
    print(PERM2020_IND_1)
    print(PERF2020_IND_1)
    print(PERM2020_COL_2)
    print(PERF2020_COL_2)
    print(PERM2020_IND_2)
    print(PERF2020_IND_2)
    
    # Imprime los nombres de las columnas de PERF2020_COL_1
    print(PERF2020_COL_1.columns)
    
    # SEGUNDO-----> GENERAMOS TODAS LAS VARIABLES CON UNA TABLA DE LAS ANTERIORES
    import numpy as np
    import pandas as pd
    
    
    class ActuarialTable:
        def init(self, qx_base: pd.Series, lambda_values: pd.Series = None,
                 birth_year: int = None, base_year: int = None,
                 interest_rate: float = 0.03, l0: int = 100000):
            self.qx_base = qx_base / 1000  # qx_base should be in ‘per thousand’ unit
            self.is_generational = lambda_values is not None and birth_year is not None and base_year is not None
            self.interest_rate = interest_rate
            self.l0 = l0
    
            if self.is_generational:
                # Adjust based on birth year if it’s a generational table
                self.lambda_values = lambda_values
                self.birth_year = birth_year
                self.base_year = base_year
                self.qx = self.adjust_qx_by_birth_year()
            else:
                # Otherwise, use the base probabilities
                self.qx = self.qx_base
    
            self.lx = [self.l0]
            self.i = i  # Tasa de interés anual efectiva
            self.l0 = l0  # Población inicial de lx
            self.lx = [l0]  # Se inicializa con la población al inicio
            self.dx = [0.0] * len(self.qx)
            self.ex = [0.0] * len(self.qx)
            self.Dx = [0.0] * len(self.qx)
            self.Nx = [0.0] * len(self.qx)
            self.Cx = [0.0] * len(self.qx)
            self.Mx = [0.0] * len(self.qx)
            self.nEx = [0.0] * len(self.qx)
    
            # Llama al método que realiza los cálculos.
            self._calculate_actuarial_variables()
    
    
        def adjust_qx_by_birth_year(self):
            return self.qx_base * np.exp(-self.lambda_values * (self.birth_year + self.qx_base.index - self.base_year))
        def _calculate_actuarial_variables(self):
            n = len(self.qx)
    
            # Calcular lx y dx
            for x in range(1, n + 1):
                lx_previous = self.lx[x - 1]
                dx = lx_previous * self.qx[x - 1]
                self.dx[x - 1] = dx
                lx = lx_previous - dx
                self.lx.append(lx)
    
            # Calcular ex (expectativa de vida) para cada edad x
            self.ex[-1] = 0  # Última expectativa de vida es 0
            for x in reversed(range(n - 1)):
                lx_sum = sum(self.lx[x + 1:])
                self.ex[x] = lx_sum / self.lx[x]
    
            # Calcular Dx y Nx
            for x in range(n):
                if self.lx[x] > 0:
                    self.Dx[x] = self.lx[x] / ((1 + self.i) ** x)
            for x in range(n):
                self.Nx[x] = sum(self.Dx[x:])
    
            # Calcular Cx y Mx
            for x in range(n - 1):
                self.Cx[x] = self.dx[x] / ((1 + self.i) ** (x + 0.5))
            for x in range(n):
                self.Mx[x] = sum(self.Cx[x:])
    
            # Calcular nEx
            for x in range(n - 1):
                if self.Dx[x] > 0:
                    self.nEx[x] = self.Nx[x + 1] / self.Dx[x]
    
            # La última edad w es inicialmente desconocida, se calculará como 0 si lx es 0
            self.w = n + self.lx[n:].index(0) if 0 in self.lx[n:] else n
    
         
    
    
    # Create an instance for a non-generational table
    non_generational_actuarial_table = ActuarialTable(non_generational_qx)
    
    # Create an instance for a generational table (with birth year adjustment)
    generational_actuarial_table = ActuarialTable(generational_qx, lambda_values, birth_year, base_year)
    

    si lo ejecuto me da este error

    Traceback (most recent call last): File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\tablasgen.py", line 248, in non_generational_actuarial_table = ActuarialTable(non_generational_qx) ^^^^^^^^^^^^^^^^^^^ NameError: name 'non_generational_qx' is not defined

  2. Assistant

    El error NameError: name 'non_generational_qx' is not defined indica que estás intentando crear una instancia de la clase ActuarialTable usando una variable llamada non_generational_qx que nunca fue definida o inicializada previamente en tu código. Similarmente, al final de tu código, también haces referencia a generational_qx, lambda_values, birth_year, y base_year, las cuales tampoco se definen en el fragmento de código proporcionado.

    Para resolver este error, necesitas definir e inicializar estas variables antes de usarlas para crear instancias de ActuarialTable. Por ejemplo, para arreglar el issue con non_generational_qx, necesitas obtener los datos qx relevantes de alguna de las tablas importadas y, seguramente, hacer algo similar para generational_qx, lambda_values, birth_year, y base_year dependiendo del contexto de tu trabajo. Esto podría ser a partir de los DataFrames que importaste anteriormente.

    Un ejemplo de esto podría ser (nota que este es solo un ejemplo y necesitarás ajustar los nombres de variables y operaciones a tus requisitos reales):

    # Suponiendo que 'PERF2020_COL_1' tiene los datos qx relevantes
    non_generational_qx = PERF2020_COL_1['qx_column_name']  # 'qx_column_name' debería ser reemplazado por el nombre verdadero de la columna
    
    # También debes definir las demás variables antes de intentar crear instancias de 'ActuarialTable'
    # Por ejemplo:
    lambda_values = None  # O tu valor real de lambda_values
    birth_year = None  # O tu valor real de birth_year
    base_year = None  # O tu valor real de base_year
    
    # Luego de que todas las variables requeridas estén definidas correctamente, puedes crear las instancias
    non_generational_actuarial_table = ActuarialTable(qx_base=non_generational_qx)
    
    # Y para una tabla generacional, asegúrate de tener los valores correctos en las variables antes de intentar esto
    generational_actuarial_table = ActuarialTable(qx_base=generational_qx, lambda_values=lambda_values, birth_year=birth_year, base_year=base_year)
    

    Por favor, ten en cuenta dos cosas importantes:

    1. Asegúrate de que los nombres de columnas utilizados (como 'qx_column_name') coincidan con los nombres reales de las columnas en tus DataFrames.

    2. Revisa la inicialización de ActuarialTable. En el código suministrado, el método __init__ está incorrectamente escrito como def init(self, ...). Debería ser def __init__(self, ...). Esto es crítico para que la inicialización de tu objeto funcione correctamente:

        def __init__(self, qx_base: pd.Series, lambda_values: pd.Series = None, 
                     birth_year: int = None, base_year: int = None, 
                     interest_rate: float = 0.03, l0: int = 100000):
            ...
    
  3. User

    ahora da este error Traceback (most recent call last): File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\tablasgen.py", line 255, in non_generational_actuarial_table = ActuarialTable(qx_base=non_generational_qx) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\tablasgen.py", line 189, in init self.i = i # Tasa de interés anual efectiva

  4. Assistant

    El error que estás observando indica que en tu método __init__ de la clase ActuarialTable, intentas asignar un valor a self.i con self.i = i, pero el valor i no está definido en cualquier parte del método __init__ (ni se pasa como argumento al método). Este es un error bastante común cuando se olvida pasar variables o utilizar variables no definidas.

    Para solucionar este problema, necesitas asegurarte de que todas las variables que utilices dentro de __init__ y otros métodos sean definidas o pasadas correctamente. En este caso específico, parece que quisieras usar interest_rate en lugar de i, dado que interest_rate es un argumento del método __init__.

    Entonces, deberías reemplazar self.i = i por self.i = interest_rate, asumiendo que el objetivo es tener self.i como tu tasa de interés anual efectiva. Aquí te muestro el fragmento pertinente de código corregido:

    class ActuarialTable:
        def __init__(self, qx_base: pd.Series, lambda_values: pd.Series = None,
                     birth_year: int = None, base_year: int = None,
                     interest_rate: float = 0.03, l0: int = 100000):
            self.qx_base = qx_base / 1000  # qx_base debería estar en ‘por mil’
            self.is_generational = lambda_values is not None and birth_year is not None and base_year is not None
            self.i = interest_rate  # Corrección aquí: Usamos interest_rate en lugar de i
            # Resto del código...
    
    

    Asegúrate de revisar todo el código para otras posibles inconsistencias o lugares donde podrías estar usando variables incorrectas o no definidas. También es una buena práctica realizar la depuración paso a paso y el uso extensivo de impresiones (print statements) o un depurador para rastrear el flujo y los valores de tu código, especialmente cuando manejas varias variables y operaciones complejas.

  5. User

    ahora da este error Traceback (most recent call last): File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\Lib\site-packages\pandas\core\indexes\base.py", line 3805, in get_loc return self._engine.get_loc(casted_key) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "index.pyx", line 167, in pandas._libs.index.IndexEngine.get_loc File "index.pyx", line 196, in pandas._libs.index.IndexEngine.get_loc File "pandas\_libs\hashtable_class_helper.pxi", line 7081, in pandas._libs.hashtable.PyObjectHashTable.get_item File "pandas\_libs\hashtable_class_helper.pxi", line 7089, in pandas._libs.hashtable.PyObjectHashTable.get_item KeyError: 'qx base 2019 en tanto por mil'

    The above exception was the direct cause of the following exception:

    Traceback (most recent call last): File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\tablasgen.py", line 257, in non_generational_qx = PASEM_DEC_1["qx base 2019 en tanto por mil"] # en verde el título de la columna de las qx ~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\Lib\site-packages\pandas\core\frame.py", line 4090, in getitem indexer = self.columns.get_loc(key) ^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\40999459g\PycharmProjects\Calc_Act_Gencat.venv\Lib\site-packages\pandas\core\indexes\base.py", line 3812, in get_loc raise KeyError(key) from err KeyError: 'qx base 2019 en tanto por mil'

  6. Assistant

    El error KeyError: 'qx base 2019 en tanto por mil' que estás viendo indica que Pandas no puede encontrar una columna llamada 'qx base 2019 en tanto por mil' en el DataFrame PASEM_DEC_1. Esto suele suceder por varias razones, aquí te indico algunas y cómo podrías resolverlas:

    1. La columna no existe:

      • Verifica que el nombre de la columna sea exactamente igual al que aparece en tu DataFrame, incluidos espacios y mayúsculas. A veces, un espacio extra o una letra en mayúscula/minúscula donde no debe ser puede causar este error.
      • Utiliza print(PASEM_DEC_1.columns) para imprimir los nombres de columnas actuales del DataFrame y verificar cómo se llama exactamente la columna que intentas utilizar.
    2. Columnas no fueron correctamente importadas:

      • Si la columna 'qx base 2019 en tanto por mil' debería haberse importado de un archivo Excel, verifica que las opciones usecols, skiprows y demás parámetros en tu llamada a pd.read_excel() sean correctos para incluir dicha columna.
    3. El nombre de la columna contiene caracteres especiales o espacios adicionales:

      • A veces, el nombre de la columna en el DataFrame puede tener caracteres especiales o espacios al inicio/final que no son inmediatamente evidentes. Para manejar esto, es útil quitar espacios extras o verificar si hay caracteres inesperados.

    Si luego de revisar los puntos anteriores aún no logras identificar la causa del error, podrías intentar acceder a las columnas de manera diferente, por ejemplo, si tu columna está en la segunda posición podrías acceder a ella por índice en lugar de por nombre:

    non_generational_qx = PASEM_DEC_1.iloc[:, 1]  # Cambia '1' por el índice real de tu columna.
    

    Recuerda, siempre es buena idea verificar los datos que tienes importados antes de procesarlos. Puedes hacer un simple print(PASEM_DEC_1.head()) para ver las primeras filas de tu DataFrame y verificar que la estructura es la que esperas, incluyendo nombres de columnas.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.