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))
Introducción
Objetivos del Curso
Programación Dinámica
Introducción a la Programación Dinámica
Optimización de Fibonacci
Caminos Aleatorios
¿Qué son los caminos aleatorios?
Entendiendo la aleatoriedad con Python
Camino de Borrachos
Desarrollando la simulación
Visualización de Caminos Aleatorios
Programas Estocásticos
Introducción a la Programación Estocástica
Cálculo de Probabilidades
Simulación de Probabilidades
Inferencia Estadística
Media
Varianza y Desviación Estándar
Distribución Normal
Simulaciones de Montecarlo
¿Qué son las Simulaciones de Montecarlo?
Simulación de Barajas
Cálculo de PI
Implementación del Cálculo de PI
Muestreo e Intervalos de Confianza
Muestreo
Teorema del Límite Central
Datos Experimentales
¿Cómo trabajar con datos experimentales?
Regresión Lineal
Conclusiones
Conclusiones
Aún no tienes acceso a esta clase
Crea una cuenta y continúa viendo este curso
Aportes 78
Preguntas 3
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:
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
El promedio para numeros entre 1 y 21 les debería de dar 11… random.randint es inclusive
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)
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.
$$\bar{X} = \frac{1}{n}\sum_{i=1}^nx_i = \frac{1}{n}(x_1 + x_2 + . . . +x_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, 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')
¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.