Cálculo de la Media Aritmética en Python paso a paso

También se puede hacer importando “statistics” para utilizar la función “mean”

import random
import statistics

if __name__ == '__main__':

    edades = [random.randint(1,35) for i in range (20)]
    print(edades)
    print(statistics.mean(edades))

Matemáticas + Programación = Felicidad!!! =)

Using Numpy

import numpy as np 

if __name__ == "__main__":
    X = np.random.randint(1 , 21 , size=20)
    mu = np.mean(X)
    print(X)
    print(mu)

sin ver la clase, intenté hacerlo con lo que sabía como reto personal, acá lo comparto, si tienen sugerencias, por favor haganmelas saber.

import random

def media(cajon):
    return sum(cajon) / len(cajon)

def X(lista):
    cajon = []

    for i in range(lista):
        cajon.append(random.randint(0,100))
        print(cajon)
    return cajon


if __name__ == '__main__':
    lista = int(input('cuantos numeros?'))
    cajon = X(lista)
    media = media(cajon)
    print(f' esta es la media {media}')

Descubrí que se pueden crear variables en Python con caracteres especiales:

import random

def media(X):
    return sum(X) / len(X)

if __name__ == '__main__':
    X = [ random.randint(1, 21) for i in range(20) ]
    µ = media(X) #Aqui
    print(X)
    print(f'Media: {µ}')

Vídeo del canal de YouTube Derivando que habla sobre:

• la media
• la varianza
• la desviación estándar
• y el coeficiente de Gini
  ➡️👌 https://www.youtube.com/watch?v=QditfY6P8uc

Me fascina la aplicación y gran utilidad de las matemáticas en este campo, es simplemente increíble!

No sé si al momento de grabar el vídeo, los rangos de random.randint() no incluían el último valor, pero en la versión actual de python sí están incluidos ambos extremos.

Esto lo pueden validar en cuadro de sugerencias que muestra VSC:

Sorprendente el poder de Python, con unas cuantas lineas se hace lo que en otros lenguajes serian muchas mas lineas.

import random

def media(X):
    return sum(X) / len(X)

if __name__ == "__main__":
    X = [random.randint(1, 21) for i in range(20)]
    print(f'El promedio es {media(X)}.')

https://github.com/karlbehrensg/programacion-dinamica-y-estocastica
Media

La media es una medida de tendencia central, comúnmente conocido como promedio. La media de una población se denota con el símbolo μ y la media de una muestra se define con X̄.

Una forma de calcular la media con Python seria la siguiente.

import random

def media(X):
    return sum(X) / len(X)

if __name__ == '__main__':
    X = [random.randint(9, 12) for i in range(20)]
    mu = media(X)

    print(f'Arreglo X: {X}')
    print(f'Media = {mu}')

Se entienden mejor los conceptos cuando se entiende la notación y se han realizado las operaciones, no desdeñen las matemáticas. Es preferible entenderlas de fondo y forma y no por ‘encimita’, es verdad que no se convertiran en matemáticos pero en nada estorba saber las cosas a profundidad. A veces noto en los cursos que le indican a la gente que no es importante saber los símbolos y las operaciones, pero ese es un error. Creo que hay que darle la importancia que merecen e indicarle a la gente que vaya a buscar información. No es queja, simplemente que creo que todas las áreas son importantes y no desdeñar el conocimiento que libremente la gente puede poseer.

import random


def media(numbers):
    sum_numbers = 0
    for number in numbers:
        sum_numbers += number

    return sum_numbers / len(numbers)


if __name__ == '__main__':
    numbers = [random.randint(0, 100) for _ in range(100)]
    print(numbers)
    print(media(numbers))```

yo soy de las personas que hubieran hecho un loop for para calcular la media jajjaa

es una boludes yo no lo hice xd

La media es el promedio de un conjunto de números

Código:

Ejecución

Hola a todos, este programa que calcula la media lo hice antes de ver el video, lo comparto por si a alguien le sirve:

<def media(valores, cantida_elementos):
    suma = sum(valores)
    media = suma / cantida_elementos
    return media

if __name__ == '__main__':
    valores = [ ]

    print('Por favor introduce los elementos cuya media quieres calcular, pero si deseas salir escribe 1989')

    while True:
        numeros = int(input('introduce digito: '))
        valores.append(numeros)
        if numeros == 1989:
            valores.remove(1989)
            break
        
    
    
    cantidad_elementos = len(valores)
    print(f'la media de los valores introducidos es {media(valores, cantidad_elementos)}')>

Es muy importante además de la media, conocer la mediana que en ciertas ocasiones puede ser más acertado. Concretamente, se dice que cuando tenemos outliers en la muestra se puede usar la mediana y no desechar estos valores extremos, ya que, a diferencia de la media la mediana no se ve afectada por éstos.

Good Class"!

>>> def media(X: list()=[]) -> float():
...     return( sum(X) / len(X) )
... 

Definición Media.

Ojo!! random.randint(1,21) me da valores hasta el 21 inclusive

import random
def media(array):
    suma=0
    for i in array:
        suma+=i
    return float(suma/len(array))

if __name__ == '__main__':
    array=[]
    array_length = random.randint(1,50)
    print(array_length)
    for i in range(0,array_length):
        array.append(random.randint(0,50))
    print(array)

    print(media(array))

import random

def media(X):
    return sum(X) / len(X)

if __name__ == "__main__":
    X = [random.randint(1,21) for i in range(20)]
    mu = media(X)
    print(X)
    print(mu)

Muy fáci por lo bien explicado.

def media(X):
    return sum(X) / len (X)

if __name__ == "__main__":
    X = [random.randint(1,21) for i in range(20)]
    mu = media(X)

    print(X)
    print(mu)

Mi resumen de la clase 📝
En estadística la media es el promedio de un conjunto de valores. Obtener la media es el primer paso en el proceso de inferencia estadística, por lo cual se convierte en un punto fundamental en la estadística, incluso en la clase anterior se hizo mención de ella dentro de la fórmula de “La ley de los grandes números”.

• Es una medida de tendencia central que nos dice donde se encuentra la mayoría de los valores de nuestra muestra, e infiere en determinar donde se encuentran la mayoría de los valores de la población objetivo.
• µ representa la media de la población
• X̅ representa la media de la muestra

Formula de la media

También podemos verla de la siguiente forma

Donde

• n: Es el tamaño de la muestra
• i: Es el indice donde se encuentra el elemento a sumar
• xi: Elemento que se encuentra en el indice i
• Σ: Simbolo de sumatoria

La formula se lee

La media es igual a la sumatoria de los elementos x desde el indice i hasta n, y ese resultado dividido entre n

😃

import random
import math
import statistics


def media(X):
    return sum(X) / len(X)


def varianza(X):
    mu = media(X)

    acumulador = 0
    for x in X:
        acumulador += (x - mu)**2

    return acumulador / len(X)


def desviacion_estandar(X):
    return math.sqrt(varianza(X))


if __name__ == '__main__':

    ###################################################
    X_20 = [random.randint(0, 10) for i in range(20)]
    mu_20 = media(X_20)
    Var_20 = varianza(X_20)
    sigma_20 = desviacion_estandar(X_20)

    #print(statistics.mean(X))

    #print(f'Arreglo X: {X_20}')
    print("""
Ejemplo de estadistica con un arreglo de 20 numeros""")
    print(f'Media = {mu_20}')
    print(f'Varianza = {Var_20}%')
    print(f'Desviacion estandar = {sigma_20}%')

    ###################################################
    X_200 = [random.randint(0, 10) for i in range(200)]
    mu_200 = media(X_200)
    Var_200 = varianza(X_200)
    sigma_200 = desviacion_estandar(X_200)

    #print(statistics.mean(X))

    #print(f'Arreglo X: {X_200}')
    print("""
Ejemplo de estadistica con un arreglo de 200 numeros""")
    print(f'Media = {mu_200}')
    print(f'Varianza = {Var_200}%')
    print(f'Desviacion estandar = {sigma_200}%')


    ###################################################
    X_2000 = [random.randint(0, 10) for i in range(2000)]
    mu_2000 = media(X_2000)
    Var_2000 = varianza(X_2000)
    sigma_2000 = desviacion_estandar(X_2000)

    #print(statistics.mean(X))

    #print(f'Arreglo X: {X_2000}')
    print("""
Ejemplo de estadistica con un arreglo de 2000 numeros""")
    print(f'Media = {mu_2000}')
    print(f'Varianza = {Var_2000}%')
    print(f'Desviacion estandar = {sigma_2000}%')

Me parece excelente que relacione y aterrice directamente los conceptos con la programación. Algo que falta mucho en la educación universitaria.

• La media es aquel valor, que tendrían todos los eventos si en todos ellos el resultado hubiera sido el mismo.

• Por este motivo, si Elon Musk vive en tu pais, inmediatamente tu ingreso per cápita anual se dispara.

Tambien, puede ser…

import scipy as sc
import random as rd

if __name__ == '__main__':
  X = [rd.randint(1,33) for _ in range(33)]
  mu = sc.mean(X)
  print(f' Lista: {X}\n Media: {mu}')

La media es una medida de tendencia central, comúnmente conocido como promedio. La media de una población se denota con el símbolo μ y la media de una muestra se define con X̄.

import numpy as np
X=[np.random.randint(1,10) for i in range(10)]
print(“X”,X)
print("="*10)
print(“media”, np.mean(X))

Cada vez que nosotros queramos comenzar nuestro script, debemos poner: if __name__ == "__main__": Pero esto, debido a que nosotros, no quisieramos que nuestros helper modules, se ejecuten cada vez que los importamos.

Dónde los matemáticos empiezan a contar en 1, los ingenieros comenzamos a contar en cero.

El promedio, se toma sumando todos los valores de una lista, para luego pasar a dividirla por la cantidad de elementos de la lista.

La media de una población de denota con la letra miu. Mientras que la media de una muestra se denota con la barra x o x bar.

Algo muy importante en estadística inferencial y algo que se toma como primer paso, es la media: El promedio de los valores. La media nos dá una medida de tendencia central, que es donde se encuentran la mayoría de los valores de nuestra muestra , lo que nos permite inferir en dónde se encuentran la mayoría de los valores de la población.

Otra forma de saca la media, digitando los valores por espacios:

def middle(x):
    return sum(x) / len(x)


if __name__ == '__main__':
    data = input().split()
    for i in range (0, len(data)):
        data[i] = int(data[i])

    x = data

    num = middle(x)
    print(num)

Que bueno poder acoplar estas herramientas desde el colegio, creo que todo el tema matemático, la simulación en física, los experimentos en química, tendrían una mejor proyección y comprensión.

Notas de la sesión 😄
Media.

• El primer paso del proceso de la inferencia es calcular la media.
• La media es el promedio de los valores, nos da una medida de tendencia central de los lados. La media de la población se denota con el símbolo $\mu$. La media de una muestra se denota como $\bar{X}$. Se define como:

$$\bar{X} = \frac{1}{n}\sum_{i=1}^nx_i = \frac{1}{n}(x_1 + x_2 + . . . +x_n)$$

• En código:

import random

def media(X):
    return sum(X) / len(X)

if __name__ == '__main__':
     
    X = [random.randint(1, 21) for i in range(20)]
    mu = media(X)
    
    print(X, mu)

¡Hola Comunidad! En base a lo que dijo el profesor Aroesti (usar la función sum en vez de un bucle for), un compañero preguntó lo siguiente: ¿Qué seria mas eficiente, usar la función sum y len para calcular la media o uno diseñar el codigo con un for? Complementé la respuesta de otros compañeros y aprovecho para compartirla también como un aporte para los que les parece útil.
.
¿Qué seria mas eficiente, usar la función sum y len para calcular la media o uno diseñar el codigo con un for?
.
Siempre es recomendable utilizar las funciones built-in de Python, por ahí he leído algunos casos en los que no es así, pero son cosas peculiares que para nuestro nivel (al menos el mío que soy un novato), no son tan urgentes.
.
Pensé que sería bueno comparar el tiempo que tarda un bucle for con el tiempo que tarda la función sum para el caso de sumar una cantidad de enteros medianamente grande.
.
Aquí el código:

import timeit

lista_de_enteros = 100000
numero_de_ejecuciones = 100

def suma_con_bucle_for():
    sumatoria = 0
    for entero in range(lista_de_enteros):
        sumatoria += entero
    return sumatoria

def suma_con_funcion_sum():
    sumatoria = sum(range(lista_de_enteros))
    return sumatoria

print("Resultado [Aplicando bucle FOR]:\t", timeit.timeit(suma_con_bucle_for, number=numero_de_ejecuciones))
print("Resultado [Aplicando función SUM]:\t", timeit.timeit(suma_con_funcion_sum, number=numero_de_ejecuciones))

Algunos de los resultados de la ejecución son:

C:\xampp\python> python .\tiempo_sum_for.py 
Resultado[Aplicando bucle FOR]:         1.4340383
Resultado[Aplicando función SUM]:       0.7051774999999998
PSC:\xampp\python> python .\tiempo_sum_for.py
Resultado[Aplicando bucle FOR]:         1.4479794
Resultado[Aplicando función SUM]:       0.7081203000000003
PSC:\xampp\python> python .\tiempo_sum_for.py
Resultado[Aplicando bucle FOR]:         1.4863573
Resultado[Aplicando función SUM]:       0.7029200999999998

El resultado en cada ejecución siempre resulta en que: El tiempo que tarda el bucle for en sumar los valores es en promedio el doble al que tarda la función sum.
.
Obviamente esto varía de acuerdo a la cantidad de valores y cantidad de ejecuciones, yo estoy apuntando los valores que hice en mis ejemplos con mis valores plasmados en el código. Si utilizas valores diferentes, de preferencia elevados, verás variaciones, sin embargo se mantiene el hecho de que la función sum siempre será más rápida para generar el cálculo.
.
Esto se debe a que la función sum está implementada en C dentro del intérprete de Python, mientras que el bucle for debe ser interpretado y manejado con la lógica de objetos de Python. La explicación técnica detallada no la sé, o mejor dicho aún no la averiguo, pero estaré revisando y lo compartiré.
.
¡Saludos!

esto ya lo vimos en el curso de probabilidad y estadistica, por que lo repiten???

Entendido

import random
import statistics

def media(X):
    return sum(X) / len(X)

if __name__ == "__main__":
    X = [random.randint(1,1000) for i in range(1000)]
    mu = media(X)
    print(f'La media de la lista {X} es mu : {mu}')

    mu_fun = statistics.mean(X)
    print(f'La media de la lista (Import statistics) {X} es mu : {mu_fun}')

Excelente

Media en código.

media

*Media: medida de tendencia central, conocida como promedio.
N–>elementos en universo
n–>elementos en muestra

def media(X):
   return sum(x)/len(X)

Programación y Matemáticas, una gran combinación.

import random

def media(X):
return sum(X)/len(X)

if name == ‘main’:
X = [random.randint(1, 21) for i in range(20)]
mu = media(X)

print(X)
print(mu)

#estadisticas.py

import random
import math

def media(X):
    return sum(X) / len(X)


def varianza(X):
    mu = media(X)

    acumulador = 0
    for x in X:
        acumulador += (x - mu)**2

    return acumulador / len(X)


def desviacion_estandar(X):
    return math.sqrt(varianza(X))


if __name__ == '__main__':
    X = [random.randint(9, 12) for i in range(20)]
    mu = media(X)
    Var = varianza(X)
    sigma = desviacion_estandar(X)

    print(f'Arreglo X: {X}')
    print(f'Media = {mu}')
    print(f'Varianza = {Var}')
    print(f'Desviacion estandar = {sigma}')```

import random
import math

def media(X):
    return sum(X) / len(X)

def varianza(X):
    mu = media(X)

    acumulador = 0
    for x in X:
        acumulador += (x - mu)**2

    return acumulador / len(X)

def desvacionestandar(X):
    return math.sqrt(varianza)

if __name__ == '__main__':
    X = [random.randint(1, 21) for i in range(20) ]
    mu = media(X)
    Var = varianza(X)
    sigma = desvacionestandar(X)
    print(X)
    print(mu)
    print(Var)
    print(sigma)``` 
chicos no se xq me saltan 5000 errores

Creo que el codigo es bastante sencillo de entender porque el profesor lo hace sencillo de entender!
Incluso por la parte matematica, nunca me lo habían explicado de una manera tan clara!

Muy buena implementacion

La media o el promedio, es la medida de tendencia central más utilizada. por lo menos en los deportes, sobre todo en el el béisbol, uno de los indicadores de mayor importancia es el promedio de bateo. Que consiste en la cantidad hits conectados, entre la cantidad de veces al bate que tiene un jugador.

Que sencillo!!

The sock.

import random
def media (X):
    return sum(X)/len(X)

if __name__=='__main__':
    X=[random.randint(1,21) for i in range(20)]
    mu=media(X)

    print(X)
    print(mu)

Media:
Medida de tendencia central. Lo que significa que es el valor que se representa a los datos siendo el valor en torno al cual ‘giran’ nuestros datos.
La calculamos dividiendo la sumatoria de todos los valores entre la cantidad de estos

en trading es super importante el tema de las medias, tambien se usan mucho las medias exponenciale, para saber si estamos en una tendencia alcista o bajista

Ya comenzamos con los conceptos estadisticos.

Fue mi impresión o los números de este programa tienden a 10.

El promedio por si solo no aporta ningun dato relevante; me sienta muy mal que arrojen noticias de “los colombianos ganan $$$$ de sueldo en promedio”

por poner un ejemplo, si 1 persona gana $1.000.000 y otra gana $9.000.000, el promedio seria de $5.000.000

La realidad es que la gran mayoria de colombianos ganan muy poco y una gran minoria colombianos gana muchisimo más en comparación. Logrando que el promedio salga alto

hay que aprender a reconocer cuando nos es util la media (promedio) y cuando no nos aporta nada util el saberlo

Buena idea el cambio de nombre del curso por algo más genérico.

Al final del día ambas derivan de la Programación Matemática (Dinámica)
Programación determinista
Programación probabilistica / estocástica

Calculo de la media utilizando ciclo for

import random

def media(arreglo):
    sumatoria = 0
    for i in range(len(arreglo)):
        sumatoria = arreglo[i] + sumatoria

    return sumatoria/len(arreglo)


if __name__ == "__main__":
    arreglo = [random.randint(1, 30) for i in range(2)]
    promedio = media(arreglo)


print(arreglo)
print(promedio)

# -*- coding: utf-8 -*-
import random as rd
import statistics as st

def mean1(X):
    return sum(X) / len(X)

# Using statistics module
def mean2(X):
    return st.mean(X)

if __name__ == '__main__':
    X = list(rd.randint(1, 20) for i in range(20))
    miu = mean2(X)
    print(miu)

Para que puedan apreciar cual es la diferencia entre una MEDIA MUESTRAL y una MEDIA POBLACIONAL hice este programa en donde se imprimen aleatoriamente edades de entre 1-80 años con una población de 10,000 personas. Ahí pueden jugar en modificar el tamaño de muestra y se darán cuenta que mientras más muestras tomen, más se acercará la media muestral a la poblacional (la “REAL”).
.
Aún así, no se necesitan tantas muestras para tener una buena estimación:
.

import random

def media (X):
    return sum(X) / len(X) #Tiene sentido 

if __name__ == "__main__": #Vamos a tener un archivo con helper
    X = [random.randint(1,80) for i in range (10000)]
    mu = media(X) #Este es LA MEDIA POBLACIONAL

    muestra = int (input('Selecciona un tamaño de la muestra: '))

    casilla_aleatoria = [] #Esto solo me genera numeros aleatorios de las CASILLAS de 0 al 2000 que NO se repitan
    i = 0
    while (i < muestra):
        aleatorio = random.randint(1,9999) #genero 2 numeros aleatorios que NO se repiten del 1-20
        if aleatorio not in casilla_aleatoria:
            casilla_aleatoria.append(aleatorio)
            i += 1

    muestra_aleatoria = []
    j = 0
    while (j < muestra):
        muestra_aleatoria.append(X[casilla_aleatoria[j]]) #Selecciona las EDADES de las personas en una CASILLA especifica
        j += 1

    X_barra = media(muestra_aleatoria)
    print (f'la media REAL de la población es {mu}')
    print (f'la media MUESTRAL de una inferencia con {muestra} muestras es de {X_barra}')```

La media no es la única medida de tendencia central. También están la moda y la mediana.
También existen tipos de media:
La media aritmética(La utilizada en esta clase)
La media geométrica

Excelente!

Algunas respuestas en este apartado:
¿Qué es la media?

Les comparto el programa que hice, realice unas modificaciones al programa del profesor, importe la librería statistics para utilizar la funcion “mean” que obtiene el promedio, así se puede verificar el cálculo de la media que estamos realizando.
Saludos

Desde hace años que uso Jupyter-Notebook, es mi herramienta principal si se habla de manipulación de datos con y sin uso de framworks (como pandas, numpy, tensorFlow, entre otros).

Hola a todos, he hecho una simulacion de la ruleta de un casino y aqui os dejo el codigo por si a alguien le sirve, si creeis que puedo hacer alguna mejora por favor decidmelo, este es el codigo:

<import random

class Ruleta:
    def __init__(self, rojo, negro, cero):
        self.rojo = rojo
        self.negro = negro
        self.cero = cero

    def simulacion(self, simulaciones):
        lista = [ ]

        for _ in range(18):
            lista.append(self.rojo)

        for _ in range(18):
            lista.append(self.negro)

        lista.append(self.cero)

        #rojos = lista.count(self.rojo)
        #negros = lista.count(self.negro)
        #ceros = lista.count(self.cero)

        paso = 1
        lista_aleatoria = [ ]

        while paso <= simulaciones:
            lista_aleatoria.append(random.choice(lista))
            paso += 1

        rojo_contar = lista_aleatoria.count(self.rojo)
        probabilidad_rojo = rojo_contar / simulaciones 

        negro_contar = lista_aleatoria.count(self.negro)
        probabilidad_negro = negro_contar / simulaciones

        cero_contar = lista_aleatoria.count(self.cero)
        probabilidad_cero = cero_contar / simulaciones

        print(f'{self.rojo} ha salido {rojo_contar} veces, y su probabilidad es {probabilidad_rojo}')
        print(f'{self.negro} ha salido {negro_contar} veces, y su probabilidad es {probabilidad_negro}')
        print(f'{self.cero} ha salido {cero_contar} veces, y su probabilidad es {probabilidad_cero}')
        #print(f'en la lista hay {rojos} rojos, {negros} negros y {ceros} ceros')


if __name__ == '__main__':
    
    ruleta = Ruleta('rojo','negro','cero')
    simulaciones = int(input('cuantas veces quieres simular la simulacion?? '))
    ruleta.simulacion(simulaciones)
>

import numpy as np
import random

if __name__ == '__main__':
    
    X = [random.randint(1, 21) for I in range(20)]
    mu = np.mean(X) #Se recomienda hacer cast list -> np.array

    print(X)
    print(mu)

Codigo.

import random

def media(x):
    return sum(x) / len(x)

if __name__ == "__main__":
    x = [random.randint(1,21) for _ in range(20)]
    mu = media(x)
    print(f'La media de x = {x} es: {mu}')

Quise hacer una prueba, un poco obvia pero solo para probar la Ley de los grandes números, y es que la media de muchos números entre 0 y 20 es 10, y si le haces un calculo de mas de 10millones de pruebas te da 10,00xxxx decimales, si haces pocos siempre sera 9,96 y así, en fin, llegue a la conclusión que entre mas datos/pruebas de probabilidades mas exacto es

import random

def media(X):
    return sum(X) / len(X)

if __name__ == "__main__":
    X = [random.randint(0,20) for i in range(10000000)]
    mu = media(X)

    print(X)
    print(mu)```

excelente

Genial

imortando numpy as np. Puedes usar:
np.mean(X)

En mis clases de probabilidad y estadística, esa “equis barra” se llamaba X testada.

import random

#Aquí es donde va ir nuestro array
def media(X):
return sum(X) / len(X)

if name == ‘main’:
#Vamos a generar valores del 1-20
X = [random.randint(1, 21)for i in range(20) ]
#mu por que es el promedio total de una poblacíon
mu = media(X)
print(X)
print(mu)

Me molestaba ver los numeros en desorden asi que le meti el algoritmo de ordenamiento por ‘mezcla’

import os
import time
import random

def ordenamiento_mezcla(lista):
    if len(lista) > 1:
        medio = len(lista) // 2
        izquierda = lista[:medio]
        derecha = lista[medio:]

        ordenamiento_mezcla(izquierda)
        ordenamiento_mezcla(derecha)
        #iteradors de sublistas
        i = 0
        j = 0
        k = 0

        while i < len(izquierda) and j < len(derecha):
            if izquierda[i] < derecha[j]:
                lista[k] = izquierda[i]
                i += 1
            else:
                lista[k] = derecha[j]
                j += 1

            k += 1
        while i < len(izquierda):
            lista[k] = izquierda[i]
            i += 1
            k += 1

        while j < len(derecha):
            lista[k] = derecha[j]
            j += 1
            k += 1
    return lista

def media(x):
    return sum(x) / len(x)

if __name__ == '__main__':
    x = [random.randint(1,21) for i in range(20)]
    mu = media(x)
    print(x)
    lista_ordenada = ordenamiento_mezcla(x)
    print(lista_ordenada)
    print(mu)

    os.system('pause')