Grupo_9_pyEj2y3.ipynb

Kernel: Python 3 (ipykernel)

# Importar las galerías
import random
import numpy as np
import math

Ej.2

#Crear una función para reescalar los datos de un vector y de las columnas de una matriz. Use map y apply_along_axis en Python 

#generar vector con 100 observaciones
v=np.random.randint(1,101,100)

#comprobar número de filas
print(v.shape) 

(100,)

#escalar el vector
def fescalar(x,a,b):
    
    out = (x-a)/(b-a)
    
    return round(out,2) #redondear a 2 decimales

#usar map
list( map( lambda x, a = np.ndarray.min(v), b = np.ndarray.max(v): fescalar(x,a,b) , v)  ) 

[0.6,
 0.06,
 0.59,
 0.16,
 0.67,
 0.0,
 0.21,
 0.54,
 0.62,
 0.58,
 0.67,
 0.03,
 0.11,
 0.13,
 0.52,
 0.18,
 0.06,
 0.4,
 0.61,
 0.49,
 0.66,
 0.23,
 0.66,
 0.02,
 1.0,
 0.55,
 0.35,
 0.54,
 0.57,
 0.49,
 0.86,
 0.46,
 0.75,
 0.28,
 0.33,
 0.75,
 0.01,
 0.56,
 0.15,
 0.6,
 0.11,
 0.12,
 0.65,
 0.27,
 0.56,
 0.47,
 0.03,
 0.47,
 0.9,
 0.9,
 0.17,
 0.33,
 0.66,
 0.29,
 0.15,
 0.42,
 0.75,
 0.09,
 0.25,
 0.76,
 0.7,
 0.63,
 0.86,
 0.11,
 0.06,
 0.25,
 0.05,
 0.87,
 0.66,
 0.61,
 0.41,
 0.73,
 0.32,
 0.37,
 0.38,
 0.59,
 0.03,
 0.29,
 0.14,
 0.07,
 0.02,
 0.19,
 0.06,
 0.31,
 0.91,
 0.62,
 0.87,
 0.01,
 0.44,
 0.74,
 0.0,
 0.92,
 0.4,
 0.43,
 0.36,
 0.03,
 0.91,
 0.06,
 0.63,
 0.59]

#generar matriz 100 x 50.
M=np.random.randint(1,100, size=(100,50))

#comprobar número de filas y columnas
print(M.shape) 

(100, 50)

#escalar la matriz con apply_along_axis

#opción 0 para aplicar a columnas
#redondea a 2 decimales con np.around
M_scalar = np.apply_along_axis(lambda x: np.around((x-x.min())/(x.max()-x.min()),2),0, M)
M_scalar

array([[0.89, 0.55, 0.24, ..., 0.54, 0.61, 0.39],
       [0.36, 0.35, 0.15, ..., 0.7 , 0.39, 0.28],
       [0.54, 0.46, 0.58, ..., 0.  , 0.61, 0.37],
       ...,
       [0.01, 0.65, 0.92, ..., 0.3 , 0.93, 0.01],
       [0.94, 0.49, 0.27, ..., 0.85, 0.96, 0.12],
       [0.23, 0.55, 0.49, ..., 0.83, 0.32, 0.82]])

Ej.3

# Pregunta 3
# Construya una función que permite realizar las siguientes operaciones a un vector: estandarizar y reescalar.
# Use **kwargs para definir estas operaciones y *args para el vector.

#3.2. Definir funciones 
    # a. Función de estandarización
def sdv(x,mean,sd):
    out = (x-mean)/sd
    return out 
    # b. Función de reescalar
def resc(x,mx,mn):
    out= (x-mx)/(mx-mn)
    return out

#3.3 Construir función 
def calculator( *list_vars, **kwargs):               #1. Usando *args y *kwargs     
    
    if   ( kwargs[ 'function' ] == "estandarizar" ): #2. si la funcion es 'estandarizar', mostrar:
        
        result =list(map(lambda x=list_vars,mean=np.mean(list_vars),std=np.std(list_vars):sdv(x,mean,std),list_vars))     
    
    elif ( kwargs[ 'function' ] == "reescalar" ) :   #2. si la funcion es 'reescalar', mostrar:

        result =list(map(lambda x=list_vars,mx=np.max(list_vars),mn=np.min(list_vars):resc(x,mx,mn),list_vars))                   
    else:
        raise ValueError( f"The function argument {kwargs[ 'function' ]} is not supported." )

    return result

# 3.4. Comprobar resultados
print(calculator( 4, 5, 6, 7, 8, function = "estandarizar" ))

[-1.414213562373095, -0.7071067811865475, 0.0, 0.7071067811865475, 1.414213562373095]

calculator( 4, 5, 6, 7, 8, function = "reescalar" )

[-1.0, -0.75, -0.5, -0.25, 0.0]