Análisis de Ventas Mensuales con NumPy: Transformaciones y Insights

Clase 9 de 32 • Curso de Python para Ciencia de Datos

Resumen

Ejercicio: Análisis de Ventas Mensuales con NumPy

El objetivo de este ejercicio es trabajar con arrays de NumPy para analizar y manipular datos de ventas de tres productos a lo largo de un año. A través de diversas operaciones, explorarás cómo usar NumPy para obtener estadísticas, realizar manipulaciones avanzadas y aplicar técnicas de indexación para extraer información clave.

Instrucciones:

Paso 1: Crear Arrays con Datos de Ventas

Usa la librería numpy para crear los siguientes arrays:
meses: un array con los nombres de los meses del año.
ventas_A, ventas_B, ventas_C: arrays que representan las ventas mensuales de tres productos diferentes.

Paso 2: Estadísticas Básicas

Calcula la media y la suma de ventas para los productos A, B y C usando las funciones de NumPy.
Imprime estos valores en el formato siguiente:
Media de ventas Producto A: <valor>
Suma de ventas Producto A: <valor>
Repite para los productos B y C.

Paso 3: Manipulación y Análisis de Datos

Total de ventas por mes: Suma las ventas de los tres productos para cada mes.
Promedio de ventas por producto: Calcula el promedio de ventas por producto.
Mes con mayor y menor ventas: Identifica qué mes tuvo el total de ventas más alto y cuál el más bajo usando las funciones np.argmax y np.argmin.

Paso 4: Operaciones Avanzadas con NumPy

Reshape y Transposición:

Crea una matriz 2D con las ventas de los tres productos y transforma su forma (reshape) a un array tridimensional con dimensiones (3, 4, 3).
Transpone la matriz de ventas para que las filas se conviertan en columnas.
Invertir arrays: Invierte las ventas de cada producto en orden de meses.
Aplanar la matriz: Convierte la matriz de ventas a un array unidimensional.

Paso 5: Análisis de Elementos Únicos

Utiliza np.unique para encontrar los elementos únicos en los datos de ventas y cuenta cuántas veces aparece cada uno.

Paso 6: Indexación y Slicing

Ventas del primer trimestre: Extrae las ventas de los tres primeros meses del año.
Indexación booleana: Selecciona los meses donde el total de ventas de los tres productos supere los 800.
Selección avanzada: Usa una lista de índices para seleccionar las ventas de los meses pares (o selecciona los meses a tu elección) y muestra esas ventas en una nueva matriz.

Andrés Felipe Barrera Naranjo

student•

Dónde está el ejercicio a realizar, en los recursos se encuentra solucionado pero no hay un enunciado con los ejercicios específicos a realizar?

frei Cortes Garzon

student•

Resumen

Ejercicio: Análisis de Ventas Mensuales con NumPy

Instrucciones:

Paso 1: Crear Arrays con Datos de Ventas

Usa la librería numpy para crear los siguientes arrays: meses: un array con los nombres de los meses del año. ventas_A, ventas_B, ventas_C: arrays que representan las ventas mensuales de tres productos diferentes.

Paso 2: Estadísticas Básicas

Calcula la media y la suma de ventas para los productos A, B y C usando las funciones de NumPy.
Imprime estos valores en el formato siguiente:
Media de ventas Producto A: <valor>
Suma de ventas Producto A: <valor>
Repite para los productos B y C.

Paso 3: Manipulación y Análisis de Datos

Total de ventas por mes: Suma las ventas de los tres productos para cada mes.
Promedio de ventas por producto: Calcula el promedio de ventas por producto.
Mes con mayor y menor ventas: Identifica qué mes tuvo el total de ventas más alto y cuál el más bajo usando las funciones np.argmax y np.argmin.

Paso 4: Operaciones Avanzadas con NumPy

Reshape y Transposición:

Crea una matriz 2D con las ventas de los tres productos y transforma su forma (reshape) a un array tridimensional con dimensiones (3, 4, 3).
Transpone la matriz de ventas para que las filas se conviertan en columnas.
Invertir arrays: Invierte las ventas de cada producto en orden de meses.
Aplanar la matriz: Convierte la matriz de ventas a un array unidimensional.

Paso 5: Análisis de Elementos Únicos

Utiliza np.unique para encontrar los elementos únicos en los datos de ventas y cuenta cuántas veces aparece cada uno.

Paso 6: Indexación y Slicing

Ventas del primer trimestre: Extrae las ventas de los tres primeros meses del año.
Indexación booleana: Selecciona los meses donde el total de ventas de los tres productos supere los 800.
Selección avanzada: Usa una lista de índices para seleccionar las ventas de los meses pares (o selecciona los meses a tu elección) y muestra esas ventas en una nueva matriz.

Hanns Maza

student•

copia y resuelve xd

months = np.array([
    'Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 
    'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'
])

product_A = np.array([150, 200, 250, 300, 220, 210, 180, 190, 230, 240, 280, 300])
product_B = np.array([180, 210, 230, 250, 270, 260, 240, 250, 270, 290, 310, 330])
product_C = np.array([200, 220, 240, 260, 280, 300, 320, 340, 360, 380, 400, 420])

Brayan Raul Kari

student•

Muchas gracias!!

Oscar Puentes

student•

Realice el Ejercicio 1 con un poco más de complejidad :

import numpy as np

# Función para ingresar los datos de los estudiantes y sus calificaciones
def ingresar_datos():
    num_estudiantes = int(input("¿Cuántos estudiantes desea ingresar? "))
    estudiantes = []
    
    for _ in range(num_estudiantes):
        nombre = input("Nombre del estudiante: ")
        calificaciones = []
        for i in range(4):
            calificacion = float(input(f"Ingresa la calificación del examen {i + 1}: "))
            calificaciones.append(calificacion)
        estudiantes.append([nombre] + calificaciones)
    
    return np.array(estudiantes)


#FUNCION PARA ENCONTRAR EL PROMEDIO POR ESTUDIANTE 

def promedio_por_estudiante(estudiantes):
    calificaciones = estudiantes[:, 1:].astype(float)
    promedios = np.mean(calificaciones, axis=0)

    for i, estudiante in enumerate(estudiantes[:, 0 ]):
        print(f"estudiante: {estudiante} Promedio: {promedios[i]}")
    return promedios


#FUNCION PARA ENCONTRAR EL PROMEDIO DE CADA EXAMEN
def promedio_examen(estudiantes):
    calificaciones = estudiantes[: , 1:].astype(float)
    promedio_examenes = np.mean(calificaciones, axis=0)
    for i, promedio in enumerate(promedio_examenes):
        print(f"Promedio examen {i + 1}: {promedio}")

#FUNCION PARA ENCONTRAR EL ESTUDIANTE CON MEJOR PUNTAJE EN EL TERCER EXAMEN 

def mayor_promedio_tercer_examen(estudiantes):
    calificaciones_tercer_examen = estudiantes[:, 3].astype(float)
    mejor_promedio_tercer_examen = np.argmax(calificaciones_tercer_examen)
    print(f"El Estudiante con mayor promedio en el examen 3 es : {estudiantes[mejor_promedio_tercer_examen, 0]} con una calificacion de {calificaciones_tercer_examen[mejor_promedio_tercer_examen]}")
#FUNCION PARA ENCONTRAR EL ESTUDIANTE CON MENOR PROMEDIO 

def promedio_menor_estudiante(estudiantes, promedios):
    indice_bajo = np.argmin(promedios)
    print(f"El estudiante con menor promedio es : {estudiantes[indice_bajo]} , con una calificacion de {promedios[indice_bajo]}")



#PROGRAMA PRINCIPAL 

def main():
    estudiantes = ingresar_datos()

    print("\n EL PROMEDIO DE CALIFICACIONES POR ESTUDIANTES: ")
    promedios = promedio_por_estudiante(estudiantes)
    print(promedios)


    print("\n EL PROMEDIO DE CADA DE EXAMEN: ")
    promedio_por_examen = promedio_examen(estudiantes)
    print(promedio_por_examen)



    print("\n EL ESTUDIANTE CON MEJOR PROMEDIO EN EL TERCER EXAMEN ES : ")
    indice_alto_tercer_examen = mayor_promedio_tercer_examen(estudiantes)
    print(indice_alto_tercer_examen)


    print("\n El ESTUDIANTE CON MENOR PROMEDIO ES: ")
    indice_bajo = promedio_menor_estudiante(estudiantes, promedios)
    print(indice_bajo)
    




if __name__ == "__main__":
    main()


    
```Cualquier consejo, los estaré leyendo gracias!!!

rodrigo nicolas merlo

student•

el tema era hacerlo con numpy no era necesario hacer una app pero esta bueno

Cristian Miguel Gómez Salazar

student•

Aquí comparto mi solución al reto: https://colab.research.google.com/drive/185pKUfOUKJC0YsRejDoE_T1nW9P3axAr?usp=sharing

Marina Barraza

student•

Caso Práctico de Análisis de Datos

El objetivo es realizar un análisis de datos de ventas mensuales para 3 productos en una tienda, durante 1 año. Donde realizaras transformaciones básicas para obtener insights valiosos sobre e rendimiento de cada una de estas ventas.

Encontraras toda la información del ejercicio en los recursos de esta clase.

Jhon Freddy Tavera Blandon

student•

FABIAN PEREZ

student•

me tomó como 1 hora y media resolver todo el el ejercicio

Dayana Castillo

student•

Juan David Rojas Heredia

student•

Aprender practicando siempre es la mejor forma de entender los temas; esta actividad fue interesante para poner en práctica lo visto en clase 📈.

import numpy as np

#Paso 1: Crear Arrays con Datos de Ventas
months = np.array([
    'Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 
    'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'
])

product_A = np.array([150, 200, 250, 300, 220, 210, 180, 190, 230, 240, 280, 300])
product_B = np.array([180, 210, 230, 250, 270, 260, 240, 250, 270, 290, 310, 330])
product_C = np.array([200, 220, 240, 260, 280, 300, 320, 340, 360, 380, 400, 420])


# Paso 2: Estadísticas Básicas
print(f"Media de ventas Producto A: {np.mean(product_A)}.\nSuma de ventas Producto A: {np.sum(product_A)}.")
print(f"Media de ventas Producto B: {np.mean(product_B)}.\nSuma de ventas Producto B: {np.sum(product_B)}.")
print(f"Media de ventas Producto C: {np.mean(product_C)}.\nSuma de ventas Producto C: {np.sum(product_C)}.")
print("\n\n\n")

#Paso 3: Manipulación y Análisis de Datos
sale_mes=np.vstack((product_A, product_B, product_C))
print(sale_mes,"\n","-"*100)
promedio_meses=np.mean(sale_mes, axis=0)
for mes, promedio in zip(months, promedio_meses):
  print(f"{mes}: {promedio:.1f}\n")
print("-"*100)
suma_meses=np.sum(sale_mes, axis=0)
for mes, suma in zip(months, suma_meses):
  print(f"{mes}: {suma:.1f}\n")
indice_maxima_gananacias=np.argmax(suma_meses, axis=0)
indice_menos_ganancias=np.argmin(suma_meses, axis=0)
print(f"El mes con mayor ganancias fue el {months[indice_maxima_gananacias]}")
print(f"El mes con menor gananacia fue el {months[indice_menos_ganancias]}")
print("\n\n\n")

# Paso 4: Operaciones Avanzadas con NumPy
ventas=np.vstack((product_A, product_B, product_C))
print(sale_mes)
print("-"*100)
reshaped_ventas=ventas.reshape(3,4, 3)
print(reshaped_ventas)
print("-"*100)
transpuesta_ventas=ventas.T
print(transpuesta_ventas)
print("-"*100)
inversa=ventas[::-1]
print(inversa)
print("-"*100)
unidimensional=ventas.flatten()
print(unidimensional)
print("\n\n\n")

#Paso 5: Análisis de Elementos Únicos
elementos_unicos, cont=np.unique(ventas, return_counts=True)
print(elementos_unicos)
print(cont)
print("\n\n\n")


#Paso 6: Indexación y Slicing
print(ventas[:, :3 ])
print("-"*100)
suma_mes=np.sum(ventas, axis=0)
print(suma_mes)
bool_index=suma_mes > 800
print(f"Los meses que superan los $800 son {months[bool_index]}")
meses_impares=[1,3,5,7,9,11]
ventas_pares=ventas[:, meses_impares]
print(ventas_pares)

LUIS GUAIQUIRIAN

student•

Hasta ahora, nada que gpt no pueda hacer por mi en 3 minutos

Jaime Lopez Hidalgo

student•

import numpy as np

meses = np.array(['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'])

ventas_A = np.random.randint(100, 500, size=12)
ventas_B = np.random.randint(100, 500, size=12)
ventas_C = np.random.randint(100, 500, size=12)

print("Ventas de Producto A:", ventas_A)
print("Ventas de Producto B:", ventas_B)
print("Ventas de Producto C:", ventas_C)

def imprimir_estadisticas(producto, ventas):
    media = np.mean(ventas)
    suma = np.sum(ventas)
    print(f'Media de ventas Producto {producto}: {media}')
    print(f'Suma de ventas Producto {producto}: {suma}')

imprimir_estadisticas('A', ventas_A)
imprimir_estadisticas('B', ventas_B)
imprimir_estadisticas('C', ventas_C)

total_ventas_por_mes = ventas_A + ventas_B + ventas_C
promedio_ventas_por_producto = np.array([[np.mean(ventas_A)], [np.mean(ventas_B)], [np.mean(ventas_C)]])
#Imprimir promedio de ventas por producto en forma de tupla
print("Promedio de ventas por producto:")
for i in range(len(promedio_ventas_por_producto)):
    print(f"Producto {i+1}: {promedio_ventas_por_producto[i][0]}")
mes_mayor_ventas = meses[np.argmax(total_ventas_por_mes)]
mes_menor_ventas = meses[np.argmin(total_ventas_por_mes)]
#Imprimir tuplas de total de ventas por mes
print("\nTotal de ventas por mes:")
for i in range(len(meses)):
    print(f"{meses[i]}: {total_ventas_por_mes[i]}")
print("\nMes con mayor ventas:", mes_mayor_ventas)
print("Mes con menor ventas:", mes_menor_ventas)

# Crear matriz 2D con las ventas de los productos
ventas_2d = np.vstack([ventas_A, ventas_B, ventas_C])
print("Matriz 2D de ventas:")
print(ventas_2d)

# Transformar la forma (reshape) de la matriz 2D a un array tridimensional
ventas_3d = ventas_2d.reshape(3, 4, 3)
print("\nArray 3D de ventas:")
print(ventas_3d)

#Transponer la matriz 'ventas_2d'
ventas_transpuesta = np.transpose(ventas_2d)
print("\nMatriz transpuesta de ventas:")
print(ventas_transpuesta)

#Transponer la matriz 'ventas_3d'
ventas_3d_transpuesta = np.transpose(ventas_3d, axes=(0, 2, 1))
print("\nArray 3D transpuesto de ventas:")
print(ventas_3d_transpuesta)

#Invertir las matriz 'ventas_A', 'ventas_B' y 'ventas_C'
ventas_A_invertido = ventas_A[::-1]
ventas_B_invertido = ventas_B[::-1]
ventas_C_invertido = ventas_C[::-1]
print("\nVentas invertidas, modo indexación:")
print("Ventas invertidas de Producto A:", ventas_A_invertido)
print("Ventas invertidas de Producto B:", ventas_B_invertido)
print("Ventas invertidas de Producto C:", ventas_C_invertido)

#Invertir las matriz 'ventas_A', 'ventas_B' y 'ventas_C' mediante la funcion 'reverse'
ventas_A_invertido2 = np.flip(ventas_A)
ventas_B_invertido2 = np.flip(ventas_B)
ventas_C_invertido2 = np.flip(ventas_C)
print("\nVentas invertidas, modo flit:")
print("Ventas invertidas de Producto A:", ventas_A_invertido2)
print("Ventas invertidas de Producto B:", ventas_B_invertido2)
print("Ventas invertidas de Producto C:", ventas_C_invertido2)

#Convertir la matriz 'ventas_2d' en una array unidimensional
ventas_aplanadas = ventas_2d.flatten()
print("\nVentas aplanadas:")
print(ventas_aplanadas)

GEORGE DARWIN GARZON MARIN

student•

Si deseo obtner el total de ventas de un mes en especifico que codigo seria el indicado?

Christopher Andrés Guano Valencia

student•

Primero puedes obtener el índice del array meses. Con numpy puedes utilizar el método where y especificar la condición. Ten en cuenta que retorna una tupla, donde la primera posición es un array con los índices de la búsqueda.

indice = np.where(meses == 'Septiembre')[0][0]

Después debes buscarlo en el array donde se sumaron los valores.

ventas_sep = total_ventas_por_mes[indice]
print(ventas_sep)

Espero haberte ayudado. ¡Nunca pares de aprender! 🚀🚀

Alvaro Lozano Rodríguez

student•

Leo los comentarios, pero sobre todo los aportes, y pienso que son muy presuntuosos. En mi caso apenas estoy aprendiendo y me pregunto o les pregunto, si saben todo eso, ¿para qué toman este curso? Siento que para mí está hecho a la medida. Un abrazo.

Juan Sebastián Parrado Gutiérrez

student•

Comparto el enlace a Google Collab con mi propuesta de solución

https://drive.google.com/file/d/1cX1ebG8F6FnWAtcQl7EXs3n_r07otJFZ/view?usp=sharing

Liliana Molina Camacho

student•

import numpy as np
#Ejercicios de cálculos de ventas de una tienda
meses= np.array(['Enero','Febrero','Marzo','Abril','Mayo','Junio','Julio','Agosto','Septiembre','Octubre','Noviembre','Diciembre'])
ventas_a= np.array([150,200,250,220,210,300,320,450,235,356,290,500])
ventas_b= np.array([100,220,350,230,280,310,300,290,270,380,250,400])
ventas_c= np.array([190,270,300,200,220,300,200,240,290,310,280,380])

# suma de ventas
suma_a= np.sum(ventas_a)
suma_b= np.sum(ventas_b)
suma_c= np.sum(ventas_c)
print(f'Suma de ventas Producto A: <{suma_a}>')
print(f'Suma de ventas Producto B: <{suma_b}>')
print(f'Suma de ventas Producto C: <{suma_c}>')

# media de ventas
media_a= np.median(ventas_a)
media_b= np.median(ventas_b)
media_c= np.median(ventas_c)
print(f'Media de ventas Producto A: <{media_a}>')
print(f'Media de ventas Producto B: <{media_b}>')
print(f'Media de ventas Producto C: <{media_c}>')

# total de ventas por mes
total_ventas = ventas_a + ventas_b + ventas_c
print(total_ventas)

#mes con mayor y menor venta
mes_mayor= np.argmax(total_ventas)
mes_menor= np.argmin(total_ventas)
print(f'Mes con mayores ventas <{meses[mes_mayor]}>')
print(f'Mes con menores ventas <{meses[mes_menor]}>')

# reshape
matriz_ventas= np.array([ventas_a, ventas_b, ventas_c])
print(f'La matriz de ventas totales es {matriz_ventas}')
matriz_ventas2= matriz_ventas.reshape(3,4,3)
print(f'La matriz de 3 dimensiones de ventas totales es {matriz_ventas2}')

#transpuesta
print(f'La transpuesta de ventas totales es {matriz_ventas.T}' )

#Invierte las ventas
print(f'Las ventas invertidas del producto A son {ventas_a[::-1]}' )
print(f'Las ventas invertidas del producto B son {ventas_b[::-1]}' )
print(f'Las ventas invertidas del producto C son {ventas_c[::-1]}' )

#Aplanar la matriz de ventas totales
print(f'Las ventas totales en matriz aplanada es {matriz_ventas.flatten()}')

#Identificando  datos únicos y número de ocurrencias
unicos, veces= np.unique(matriz_ventas, return_counts=True)
print(f'Los datos de ventas únicos son {unicos} con frecuencia {veces}')
diccionario_unicos = dict(zip(unicos,veces))
print(f'Diccionario de ventas con el número de ocurrencias {diccionario_unicos}')

#Ventas de los 3 primeros meses
matriz_trimestre1= matriz_ventas[:,0:3]
print(matriz_trimestre1)

#Selecciona los meses donde el total de ventas de los 3 productos supere los 800
matriz800= total_ventas>800
print(matriz800)
print(f'Meses que superan los 800 en ventas {meses[matriz800]}')

#Usa una lista de índices para seleccionar las ventas de los meses pares (o selecciona los meses a tu elección) y muestra esas ventas en una nueva matriz.
indices= np.array([1,3,5,7,9,11])
print(f'Ventas de los meses pares {matriz_ventas[:,indices]}')

Thomas Restrepo

student•

months = np.array(["Enero", "Febrero", "Marzo", "Abril", "Mayo", 
                   "Junio", "Julio", "Agosto", "Septiembre", 
                   "Octubre", "Noviembre", "Diciembre"])

def show_month_with_stat(months, stats):

  for month, stat in zip(months, stats): 

    print(f"{month} - {stat}") 

def return_sum_array(data, name): 
  sum = np.sum(data)
  print(f"The sum of {name} is: {sum}")

def calculate_average(data, name):

  average = np.average(data) 
  print(f"The average of {name} is: {int(average)}")

print("------------------------------------------")

sales_a = np.array([100, 150, 200, 130, 90, 95, 140, 110, 80, 130, 110, 120])
sales_b = np.array([200, 300, 1000, 110, 200, 400, 600, 700, 200, 100, 100, 100])
sales_c = np.array([250, 310, 600, 400, 280, 450, 600, 420, 200, 100, 1000, 100])

sum_all_sales = sales_a + sales_b + sales_c
show_month_with_stat(months, sum_all_sales)

print("------------------------------------------")

return_sum_array(sales_a, "sales_a")
return_sum_array(sales_b, "sales_b")
return_sum_array(sales_c, "sales_c")

gross_sales = sum(sum_all_sales)
print("The gross sale total is: ", gross_sales)


print("------------------------------------------")
calculate_average(sales_a, "sales_a")
calculate_average(sales_b, "sales_b")
calculate_average(sales_c, "sales_c")


print("------------------------------------------")

max_sales = np.argmax(sum_all_sales)
print(f"The month with more sale was {months[max_sales]} with {sum_all_sales[max_sales]}")

min_sales = np.argmin(sum_all_sales)
print(f"The month with less sale was {months[min_sales]} with {sum_all_sales[min_sales]}")


matrix_months = np.array([sales_a, sales_b, sales_c])
print("Matrix reshape \n", matrix_months.reshape(3,4,3))

print("\n")

print("Matrix transposition \n", matrix_months.T)

print("-----------------------------------------")


print("Inversed arrays")
print(np.flip(sales_a))
print(np.flip(sales_b))
print(np.flip(sales_c))


print("Flatten matrix", matrix_months.flatten())

###SEARCHING THE UNIQUE VALUES 

##FOR IN PRINT APPLYING THE \N
values, count = np.unique(matrix_months, return_counts=True)
print("\n".join([f"The value {value} appears {number} \n" for value, number in zip(values, count)]))


##INDEXATION BOOLEAN
months_with_good_sales = sum_all_sales > 800
index_good_sales = np.where(months_with_good_sales)

months_with_good_sales = months[index_good_sales]
print("Months with good sales", months_with_good_sales)


print("------------------------------------------------")


sales_with_months = np.array([months, sales_a, sales_b, sales_c])
print(f"First three months {sales_with_months[0:, :3]}")


print("------------------------------------------------")
##SEARCH SOME INDEX TO THE SAME TIME
even_months = matrix_months.flatten()[[2, 4, 6, 8, 10, 12]]
print(even_months)

JEAN BERNAL

student•

Les comparto mi ejercicio:

https://colab.research.google.com/drive/1vIuVCyGvvUhXEgprCxqr1R2tQhfKtqZw#scrollTo=q6Y3WJwWjxwD

Francisco Roberto Gomez

student•

Resolución

import numpy as np

"""
Paso 1
meses: un array con los nombres de los meses del año.  
ventas_A, ventas_B, ventas_C: arrays que representan las ventas mensuales de tres productos diferentes.

"""

meses = np.array(['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'])
productoA= np.array([150,200,250,300,220,210,180,190,230,240,280, 300])
productoB= np.array([180,210,230,250,270,260,240,250,270,290,310,330])
productoC= np.array([200,220,240,260,280,300,320,340,360,380,400,420])


"""
Paso 2 Calcula la media y la suma de ventas para los productos A, B y C usando las funciones de NumPy.

"""
print("Media de Producto")

media_producto_A=  np.mean(productoA)
print("Media del producto A es: ", media_producto_A)

media_producto_B= np.mean(productoB)
print("Media del producto B es: ", media_producto_B)

media_producto_C=  np.mean(productoC)
print("Media del producto A es: ", media_producto_C)


print("Suma de Producto")

suma_producto_A=  np.sum(productoA)
print("Suma del producto A es: ", suma_producto_A)

suma_producto_B=  np.sum(productoB)
print("Suma del producto B es: ", suma_producto_B)

suma_producto_C=  np.sum(productoC)
print("Suma del producto C es: ", suma_producto_C)

#Esto se pudo haber mejorado con una funcion que llamara al metodo y le pasara el array por parametro

"""
Paso 3: Manipulación y Análisis de Datos
- Total de ventas por mes: Suma las ventas de los tres productos para cada mes.
- Promedio de ventas por producto: Calcula el promedio de ventas por producto.
- Mes con mayor y menor ventas: Identifica qué mes tuvo el total de ventas más alto y cuál el más bajo usando las funciones np.argmax y np.argmin.
"""

Total_VentasXMes= productoA + productoB + productoC

for i in range(0, 12):
    print(f"Total de Ventas del mes {meses[i]} = {Total_VentasXMes[i]} ")

print(meses)
print(Total_VentasXMes)
 
mediaVentasXProducto= np.array([media_producto_A, media_producto_B, media_producto_C])
print(f"Media por producto A, B y C---> {mediaVentasXProducto}")


mes_menor_venta= np.argmin(productoA)
print(f"El mes de peor venta del producto A es {meses[mes_menor_venta]}= {productoA[mes_menor_venta]}") 

mes_menor_venta= np.argmin(productoB)
print(f"El mes de peor venta del producto B es {meses[mes_menor_venta]}= {productoB[mes_menor_venta]}") 

mes_menor_venta= np.argmin(productoC)
print(f"El mes de peor venta del producto C es {meses[mes_menor_venta]}= {productoC[mes_menor_venta]}") 

mes_menor_venta= np.argmin(Total_VentasXMes)
print(f" Mes de menor Ventas Totales {meses[mes_menor_venta]}= {Total_VentasXMes[mes_menor_venta]}")


mes_mayor_venta= np.argmax(productoA)
print(f"El mes de mayor venta del producto A es {meses[mes_mayor_venta]}= {productoA[mes_mayor_venta]}") 

mes_mayor_venta= np.argmax(productoB)
print(f"El mes de mayor venta del producto B es {meses[mes_mayor_venta]}= {productoB[mes_mayor_venta]}") 

mes_mayor_venta= np.argmax(productoC)
print(f"El mes de mayor venta del producto C es {meses[mes_mayor_venta]}= {productoC[mes_mayor_venta]}")  

mes_mayor_venta= np.argmax(Total_VentasXMes)
print(f" Mes de mayor Ventas Totales {meses[mes_mayor_venta]}= {Total_VentasXMes[mes_mayor_venta]}")

"""
Paso 4: Reshape y Transposición:

- Crea una matriz 2D con las ventas de los tres productos y transforma su forma (reshape) a un array tridimensional con dimensiones (3, 4, 3).
- Transpone la matriz de ventas para que las filas se conviertan en columnas.
- Invertir arrays: Invierte las ventas de cada producto en orden de meses.
- Aplanar la matriz: Convierte la matriz de ventas a un array unidimensional.

"""

#ACORDATE EL NUMERO DE CORCHETES ME INDICA LA DIMENSIONALIDAD 

productoA_B_C_2D= np.array([[150,200,250,300,220,210,180,190,230,240,280, 300],[180,210,230,250,270,260,240,250,270,290,310,330],[200,220,240,260,280,300,320,340,360,380,400,420]])
print(productoA_B_C_2D)

# Otra forma ventas_matrix = np.array([ventas_A, ventas_B, ventas_C])

print("Cambio de forma")
reshaped_array= productoA_B_C_2D.reshape(3, 4, 3)
print(reshaped_array)

print("Transupuesta")
transpuesta_producto= productoA_B_C_2D.T
print(transpuesta_producto)

print("Invierte Array")
meses_invertido= meses[::-1].copy()

productoA_invertido = productoA[::-1].copy()
productoB_invertido = productoB[::-1].copy()
productoC_invertido = productoC[::-1].copy()
print(meses_invertido)
print(productoA_invertido)
print(productoB_invertido)
print(productoC_invertido)

print("Ventas_Aplanado")
Ventas_Aplanado= productoA_B_C_2D.flatten()
print(Ventas_Aplanado)

"""
Paso 5: Análisis de Elementos Únicos
Utiliza np.unique para encontrar los elementos únicos en los datos de ventas y cuenta cuántas veces aparece cada uno.
"""

print("Elementos y Conteo")
elementos_unico,conteo= np.unique(Ventas_Aplanado, return_counts=True )

print("Elementos unicos", elementos_unico)
print("Conteo", conteo)


"""
**Paso 6: Indexación y Slicing**

- Ventas del primer trimestre: Extrae las ventas de los tres primeros meses del año.
- Indexación booleana: Selecciona los meses donde el total de ventas de los tres productos supere los 800.
- Selección avanzada: Usa una lista de índices para seleccionar las ventas de los meses pares (o selecciona los meses a tu elección) y muestra esas ventas en una nueva matriz
"""

ventas_primer_Trimestre= np.array(Total_VentasXMes[0:3])
print("Ventas totales primer trimestre ", ventas_primer_Trimestre)

ventas_mayor_cond= Total_VentasXMes>800
print(meses[ventas_mayor_cond])

print("Seleccion avanzada")
par = [0, 2, 4, 6, 8, 10]
ventas_par_seleccionados = productoA_B_C_2D[:, par]
print("Ventas en meses seleccionados:\n", ventas_par_seleccionados)
     
```Consola:

    Media de Producto

Media del producto A es:  229.16666666666666

Media del producto B es:  257.5

Media del producto A es:  310.0

Suma de Producto

Suma del producto A es:  2750 &#x20;

Suma del producto B es:  3090 &#x20;

Suma del producto C es:  3720

Total de Ventas del mes Enero = 530  &#x20;

Total de Ventas del mes Febrero = 630&#x20;

Total de Ventas del mes Marzo = 720

Total de Ventas del mes Abril = 810

Total de Ventas del mes Mayo = 770

Total de Ventas del mes Junio = 770

Total de Ventas del mes Julio = 740

Total de Ventas del mes Agosto = 780

Total de Ventas del mes Septiembre = 860

Total de Ventas del mes Octubre = 910

Total de Ventas del mes Noviembre = 990

Total de Ventas del mes Diciembre = 1050

\['Enero' 'Febrero' 'Marzo' 'Abril' 'Mayo' 'Junio' 'Julio' 'Agosto'

&#x20;'Septiembre' 'Octubre' 'Noviembre' 'Diciembre']

\[ 530  630  720  810  770  770  740  780  860  910  990 1050]

Media por producto A, B y C---> \[229.16666667 257.5        310.        ]

El mes de peor venta del producto A es Enero= 150

El mes de peor venta del producto B es Enero= 180

El mes de peor venta del producto C es Enero= 200

&#x20;Mes de menor Ventas Totales Enero= 530

El mes de mayor venta del producto A es Abril= 300

El mes de mayor venta del producto B es Diciembre= 330

El mes de mayor venta del producto C es Diciembre= 420

&#x20;Mes de mayor Ventas Totales Diciembre= 1050

\[\[150 200 250 300 220 210 180 190 230 240 280 300]

&#x20;\[180 210 230 250 270 260 240 250 270 290 310 330]

&#x20;\[200 220 240 260 280 300 320 340 360 380 400 420]]

Cambio de forma

\[\[\[150 200 250]

&#x20; \[300 220 210]

&#x20; \[180 190 230]

&#x20; \[240 280 300]]



&#x20;\[\[180 210 230]

&#x20; \[250 270 260]

&#x20; \[240 250 270]

&#x20; \[290 310 330]]



&#x20;\[\[200 220 240]

&#x20; \[260 280 300]

&#x20; \[320 340 360]

&#x20; \[380 400 420]]]

Transupuesta

\[\[150 180 200]

&#x20;\[200 210 220]

&#x20;\[250 230 240]

&#x20;\[300 250 260]

&#x20;\[220 270 280]

&#x20;\[210 260 300]

&#x20;\[180 240 320]

&#x20;\[190 250 340]

&#x20;\[230 270 360]

&#x20;\[240 290 380]

&#x20;\[280 310 400]

&#x20;\[300 330 420]]

Invierte Array

\['Diciembre' 'Noviembre' 'Octubre' 'Septiembre' 'Agosto' 'Julio' 'Junio'

&#x20;'Mayo' 'Abril' 'Marzo' 'Febrero' 'Enero']

\[300 280 240 230 190 180 210 220 300 250 200 150]

\[330 310 290 270 250 240 260 270 250 230 210 180]

\[420 400 380 360 340 320 300 280 260 240 220 200]

Ventas\_Aplanado

\[150 200 250 300 220 210 180 190 230 240 280 300 180 210 230 250 270 260

&#x20;240 250 270 290 310 330 200 220 240 260 280 300 320 340 360 380 400 420]

Elementos y Conteo

Elementos unicos \[150 180 190 200 210 220 230 240 250 260 270 280 290 300 310 320 330 340

&#x20;360 380 400 420]

Conteo \[1 2 1 2 2 2 2 3 3 2 2 2 1 3 1 1 1 1 1 1 1 1]

Ventas totales primer trimestre  \[530 630 720]

\['Abril' 'Septiembre' 'Octubre' 'Noviembre' 'Diciembre']

Seleccion avanzada

Ventas en meses seleccionados:

&#x20;\[\[150 250 220 180 230 280]

&#x20;\[180 230 270 240 270 310]

&#x20;\[200 240 280 320 360 400]]

Iván Villarroel

student•

Estoy algo oxidado pero así es como me quedó.

https://colab.research.google.com/drive/1FFenpGwp5R-Sn0hde_SVIYVZafC17qcQ?usp=sharing

Hanns Maza

student•

import numpy as np
import matplotlib.pyplot as plt
``````python
months = np.array([
    'Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 
    'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'
])

product_A = np.array([150, 200, 250, 300, 220, 210, 180, 190, 230, 240, 280, 300])
product_B = np.array([180, 210, 230, 250, 270, 260, 240, 250, 270, 290, 310, 330])
product_C = np.array([200, 220, 240, 260, 280, 300, 320, 340, 360, 380, 400, 420])
``````python
# suma total y promedio

total_A = np.sum(product_A)
total_B = np.sum(product_B)
total_C = np.sum(product_C)

print("Rendimiento total anual:")
print(f"Producto A: {total_A}")
print(f"Producto B: {total_B}")
print(f"Producto C: {total_C}")

average_A = np.mean(product_A)
average_B = np.mean(product_B)
average_C = np.mean(product_C)

print("\nRendimiento promedio mensual:")
print(f"Producto A: {average_A}")
print(f"Producto B: {average_B}")
print(f"Producto C: {average_C}")
``````python
plt.figure(figsize=(10, 6))

plt.plot(months, product_A, marker='o', label='Producto A')
plt.plot(months, product_B, marker='s', label='Producto B')
plt.plot(months, product_C, marker='^', label='Producto C')

plt.xlabel('Meses')
plt.ylabel('Ventas')
plt.title('Rendimiento mensual de los productos en el año')

plt.legend()
plt.grid(True)
plt.xticks(rotation=45)
plt.tight_layout()

plt.show()
``````python
product_total = product_A + product_B + product_C

plt.figure(figsize=(10, 6))

plt.plot(months, product_total, marker='o', label='Total de Productos')

plt.xlabel('Meses')
plt.ylabel('Ventas Totales')
plt.title('Rendimiento mensual total de los productos en el año')
plt.legend()
plt.grid(True)
plt.xticks(rotation=45)
plt.tight_layout()

plt.show()

print(product_total)