Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Simulación de Probabilidades

11/24
Recursos

Aportes 274

Preguntas 35

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Que tal!!
Modifique un poco el codigo para visualizar como conforme mas intentos realices tiende mas a un numero en especifico y en este caso 0.1666666:

Saludos!!

Me salio que la probabilidad es 0.2485 UwU

<import random

def tirar_dados(numero_de_intentos):
    secuencia_de_tiros = []

    for _ in range(numero_de_intentos):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        tiro2 = random.choice([1, 2, 3, 4, 5, 6])
        resultado = tiro + tiro2
        secuencia_de_tiros.append(resultado)


    return secuencia_de_tiros

def main(numeros_de_tiros, numero_de_intentos):
    tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numeros_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    probabilidad_de_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en {numeros_de_tiros} es: {probabilidad_de_tiros_con_12}')



if __name__ == "__main__":
    numeros_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    main(numeros_de_tiros, numero_de_intentos)>

TEORÍA:

RESULTADO:

CÓDIGO:

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([2,3,4,5,6,7,3,4,5,6,7,8,4,5,6,7,8,9,5,6,7,8,9,10,6,7,8,9,10,11,7,8,9,10,11,12])
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1
    
    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener x lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')


if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros del dado : '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion : '))

    main(numero_de_tiros, numero_de_intentos)```

solucion para tirar un numero n de dados y buscar un valor n:

def tirar_dados(numero_de_tiros, numero_de_dados):
    secuencia_de_tiros = []
    if numero_de_dados <= 0:
        numero_de_dados = 1

    for _ in range(numero_de_tiros):
        tiro = 0
        for _ in range(numero_de_dados):
            tiro += random.choice([1,2,3,4,5,6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros   

def probabilidad_existir(tiros, numero_de_intentos,valor_del_dado_buscado):
    

    tiros_con_valor_buscado = 0
    for tiro in tiros:
        if valor_buscado in tiro:
            tiros_con_valor_buscado += 1

    probabiblidad_de_tiros_con_1 = tiros_con_valor_buscado / numero_de_intentos
    print(f'Cual es la probabiblidad de obtener por lo menos un {valor_buscado} en {numero_de__tiros} = {probabiblidad_de_tiros_con_1}')
    

def main(numero_de_tiros, numero_de_intentos, numero_de_dados, valor_buscado):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numero_de_tiros, numero_de_dados)
        tiros.append(secuencia_de_tiros)


    probabilidad_existir(tiros, numero_de_intentos, valor_buscado)

    

if __name__ == "__main__":
    numero_de__tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    numero_de_dados = int(input('Numero de dados: '))
    valor_buscado = int(input('Cual es el valor buscado: '))

    main(numero_de__tiros, numero_de_intentos, numero_de_dados, valor_buscado)

implementacion para hallar un aproximado de la probabilidad de obtener una suma m con n dados

resultado con matemáticas
El total de combinaciones de 2 dados es 36 y el total de combinaciones de 2 dados que nos dan de suma 12 es 1 entonces :
Para 1 tiro de dados la probabilidad seria:

Para 10 tiros se usaría la Probabilidad “A o B”. O sucede que en el primer tiro los dados suman 12 o sucede en el 2do tiro así sucesivamente Entonces

Resultado del programa
Para 1 tiro:

Para 10 tiros:

ya que han dejado el código, mi aporte sera analítico. La probabilidad de obtener por lo menos 12 en n tiros seria. (1/36)^n. Recuerden que se hace la suposición que los dados están marcados, esto nos permite “diferenciarlos”, así las parejas serán del tipo (dado_1, dado_2), lo cual nos permite diferenciar por ejemplo (1,2) de (2,1) . Si no hacemos esta suposición solo tendríamos 36/2=18 resultados posibles distintos.

Comparto mi codigo 😄! Esta para realizarse con bokeh 😄! espero feedback

import random
from bokeh.plotting import figure,show


def got_sequences(throws):
    sequence = []

    for _ in range(throws):
        option_got = random.choice([1, 2, 3, 4, 5, 6])
        sequence.append(option_got)
    return sequence



def graph(sim,prob,sum_to_reach,throws):
    plot = figure(title=print(f'Probability of having {sum_to_reach} in {throws} throws'),
                    x_axis_label = "Attempts",
                    y_axis_label = "Probability")
    plot.line(sim,prob)
    show(plot)



def main(throws, sum_to_reach, number_of_tries):
    favorable_cases = 0
    simulations = []
    probabilities = []
    j = 1
    ranges_of_simulations= range(1,number_of_tries,100)
    for r in range(number_of_tries):
        i=0
        for i in range(throws):
            throw_sequences_1 = got_sequences(throws)
            throw_sequences_2 = got_sequences(throws)
            if (throw_sequences_1[i]+throw_sequences_2[i]) == sum_to_reach:
                favorable_cases += 1
                break
            else:
                i = +1
        probability = favorable_cases/number_of_tries
        if r in ranges_of_simulations:
            simulations.append(r)
            probabilities.append(probability)
    print(f'La probabilidad de tener el numero 12 en {number_of_tries} intentos es de {probability}')
    graph(simulations,probabilities,sum_to_reach,throws)

if __name__ == "__main__":
    throws = int(input("How many throws do you want?"))
    sum_to_reach = int(input("What's goind to be the sum?"))
    number_of_tries = int(input("How many tries do you want?"))
    main(throws, sum_to_reach, number_of_tries)

El cambio que se la hace al código es en la parte tirar dado, como ya hay dos dados, entonces quieres decir que habrá un tiro_1, y tiro_2
salu2

import random

def tirar_dado(numero_tiros):
    secuencia_de_tiros = [ ]

    for _ in range(numero_tiros):
        tiro_1 = random.choice([1,2,3,4,5,6])
        tiro_2 = random.choice([1,2,3,4,5,6])
        tiro = tiro_1 + tiro_2
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros,numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_1=0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_1 += 1


    probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos
    print(f'Probabilidad de  obtener por lo menos un 1 en {numero_de_tiros} tiros={probabilidad_tiros_con_1}')



if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tidros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correrá la simulación: '))
    main(numero_de_tiros, numero_de_intentos)

yo la hice a mi manera y pues eliges un valor entre 2 y 12 (valor minimo y maximo al tirar dos dados) y cuantos intentos quieres y ya te da la respuesta

import random

def tiro(repeticiones, valor_objetivo):
    resultado_positivos = 0
    
    for _ in range(repeticiones):
        suma_lanzamiento_dados = 0
        tiros_del_dado = 2 

        for _ in range(tiros_del_dado): 
            valor_dado = random.choice([1, 2, 3, 4, 5, 6]) # valor aleatorio del dado
            suma_lanzamiento_dados += valor_dado

        if suma_lanzamiento_dados==valor_objetivo:
            resultado_positivos += 1

    return print(f'la probabilidad de obtener {valor_objetivo} es de {(resultado_positivos/repeticiones)*100}%')  

if __name__ == "__main__":
    
    valor_objetivo = int(input("ingrese el valor del cual desea conocer la probabilidad al lanzar el dado 2 veces (valor entre 2 y 12) \n"))
    
    while (valor_objetivo < 2 or valor_objetivo > 12):
        valor_objetivo = int(input("ingrese el valor del cual desea conocer la probabilidad al lanzar el dado 2 veces (valor entre 2 y 12) \n"))
    
    repeticiones = int(input("cuantos veces quiere repetir la prueba \n"))

    tiro(repeticiones, valor_objetivo)

Cuantos tiros del dado? 10
Cuantas veces quiere correr la simulación? 100000
Probabilidad de obtener por lo menos un 12 en 10 tiros es = 0.24691
Probabilidad de no obtener por lo menos un 12 en 10 tiros es = 0.75309

Solo modifique la función en donde se lanza el dado, para que lance 2 y sume el resultado:

<code>
def tirar_dado(numero_de_tiros):
    secuencia_de_tiros=[]
    for _ in range(numero_de_tiros):
        Dado1 = random.choice([1, 2, 3, 4, 5, 6])
        Dado2 = random.choice([1, 2, 3, 4, 5, 6])
        tiro = Dado1 + Dado2
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

Modifiqué la función para poder hallar la probabilidad de que en un número de tiradas sumen ese un número en concreto.
Por ejemplo hallar la probabilidad de tirar 3 veces el dado y que los 3 resultados de las tiradas sumen 12.

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    
    tiros_con_suma12 = 0
    for tiro in tiros:
        if sum(tiro) == sumatorio_probabilidad:
            tiros_con_suma12 += 1

    probabilidad_tiros_con_suma12 = tiros_con_suma12 / numero_de_intentos
    print(f'Probabilidad de obtener la suma de 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_suma12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantas tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    sumatorio_probabilidad = int(input('De que número quieres hallar la probabilidad de la suma de las tiradas: '))

    main(numero_de_tiros, numero_de_intentos)

Comportamiento gráfico de la probabilidad de que aparezca una sumatoria de un numero dado (12 en este caso) según el número de tiros que se ejecuten:

Código

Lo interesante es también tener en cuenta que la “aleatoriedad” no existe en el mundo de las ciencias de la computación. Todas son solo aproximaciones teóricas de aletariedad posibles a través de 0’s y 1’s.

Lo hice de esta forma:

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([
            (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6),
            (1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2),
            (1, 3), (2, 3), (3, 3), (4, 3), (5, 3), (6, 3),
            (1, 5), (2, 5), (3, 5), (4, 5), (5, 5), (6, 5),
            (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6),
            (1, 4), (2, 4), (3, 4), (4, 4), (5, 4), (6, 4)])
        secuencia_de_tiros.append(tiro)
    
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    
    tiros_suma_12 = 0
    for tiro in tiros:
        if (6, 6) in tiro:
            tiros_suma_12 += 1
    
    probabilidad_tiros_suma_12 = tiros_suma_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un uno en {numero_de_intentos} tiros = {probabilidad_tiros_suma_12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantaos tiros del dado: '))
    numero_de_intentos = int(input('Cuantaos veces corre la simulación: '))

    main(numero_de_tiros, numero_de_intentos)```

la probabilidad de par 6 en 1 lanzamientos es de: 3.1 %
número de simulaciones: 1000

la probabilidad de par 6 en 4 lanzamientos es de: 11.4 %
número de simulaciones: 1000

la probabilidad de par 6 en 4 lanzamientos es de: 10.96 %
número de simulaciones: 10000

from dado import Dado

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    dado = Dado()
    for _ in range(numero_de_intentos):
        secuencia_de_tiros_1 = dado.lanzar_dado(numero_de_tiros)
        secuencia_de_tiros_2 = dado.lanzar_dado(numero_de_tiros)
        tiros.append([secuencia_de_tiros_1, secuencia_de_tiros_2])

    tiros_par_6 = 0
    for secuencia in tiros:
        for idx in range(len(secuencia[0])):
            if secuencia[0][idx] == secuencia[1][idx] and secuencia[0][idx] == 6:
                tiros_par_6 += 1

    probabilidad_de_tiros_par_6 = (tiros_par_6 / numero_de_intentos) * 100
    print(f'la probabilidad de par 6 en {numero_de_tiros} lanzamientos es de: {probabilidad_de_tiros_par_6} %')

        

if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros del dado quieres dar: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulación: '))

    main(numero_de_tiros, numero_de_intentos)

Hora de ir al casino!

lo solucione así, ademas de agregar la posibilidad de buscar cualquier numero entre 2 a 12

import random

def dado():
  return random.choice([1, 2, 3, 4, 5,6])

def tirar_dado(numero_de_tiros):
  secuencia_de_tiros = []

  for _ in range(numero_de_tiros):
    tiro = (dado(), dado())
    secuencia_de_tiros.append(tiro)

  return secuencia_de_tiros

def main(numero,numero_de_tiros, numero_de_intentos):
  tiros_dado = []
  for _ in range(numero_de_intentos):
    secuencia_de_tiros = tirar_dado(numero_de_tiros)
    tiros_dado.append(secuencia_de_tiros)

  tiros_con_numero = 0
  for tiro in tiros_dado: 
    if sum(tiro[0]) == numero:
      tiros_con_numero +=1
    
  probabilidad_tiros_con_numero = tiros_con_numero / numero_de_intentos
  print(f'Probabilidad de no obtener por lo menos un {numero} en {numero_de_tiros} tiro = {probabilidad_tiros_con_numero}')

if __name__ == '__main__':
  numero = int(input('Ingrese numero a calcular: '))
  numero_de_tiros = int(input('Cuantos tiros del dado: '))
  numero_de_intentos = int(input('Cuantos veces correra la simulacion: '))

  main(numero, numero_de_tiros, numero_de_intentos)```
import random
# obtener un 12 en 10 tiros

def dado(tiros):
	sec_tiros = []
	for _ in range(tiros):
		d1 = random.choice([1,2,3,4,5,6])
		d2 = random.choice([1,2,3,4,5,6])
		sec_tiros.append(d1 + d2)
	return sec_tiros

def main(tiros, intentos):
	n_tiros = []
	for _ in range(intentos):
		secuencia = dado(tiros)
		n_tiros.append(secuencia)
	tiros_12 = 0
	for tiro in n_tiros:
		if 12 in tiro:
			tiros_12 += 1
	prob_12 = tiros_12 / intentos
	print(prob_12)

if __name__ == '__main__':
	tiros = int(input("Total de tiros: "))
	intentos = int(input("Total de intentos: "))
	main(tiros, intentos)

El siguiente código que devuelve las veces que sale cada número cuando se tiran 2 dados 1000000, suponiendo que el número resultante es la suma de los números que salen en los dos dados.

Por lo tanto, si alguna vez apuestan a tirar dos dados, apuesten al número 7, tiene más probabilidades de salir.

Si quieren profundizar más en este les recomiendo la sección de Probabilidad y Estadística del Curso de Fundamentos de Matemáticas para Física.

Hola! aquí mi código para que salga el 12

import random
from bokeh.plotting import figure, show

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        dado1 = random.choice([1, 2, 3, 4, 5, 6])
        dado2 = random.choice([1, 2, 3, 4, 5, 6])
        resultado = dado1 + dado2
        secuencia_de_tiros.append(resultado)

    return secuencia_de_tiros

def graficar(x, y):
    grafica = figure(title='Probabilidad del resultado', x_axis_label = 'Intentos', y_axis_label = 'Probabilidad')
    grafica.line(x, y, line_width=2)

    show(grafica)

def main(numero_de_tiros, numero_de_intentos):

    tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0     #Para determinar cuantas veces sale el número deseado
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    probabilidad_tiros = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros}')

    graficar(numero_de_intentos, probabilidad_tiros)

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuántos tiros del dado: '))
    numero_de_intentos = int(input('Cuántas veces correrá la simulación: '))

    main(numero_de_tiros, numero_de_intentos)

Sin embargo no logro hacer bien el gráfico, alguien me podría indicar que va mal? Gracias de antemano!

Hola!!!
Les comparto mi version de este codigo. Escribí una funcion que toma un numero de tiros, de dados, de intentos y un evento a evaluar (n). Para hacer la sumatoria de los dados y la sumatoria de los eventos favorables utilice funciones de NumPy, lo cual ahorra un par de lineas y un poco de tiempo a la hora de correr el programa.

Este fue el resultado que obtuve con 100’000.000 de intentos:

-Probabilidad de obtener por lo menos un 12 en 10 tiros = 0.27777534

-Tiempo transcurrido = 111.8607592 segundos

Este es el codigo:

from numpy import random, sum
import time


def main(numero_de_tiros: int, numero_de_dados: int, numero_de_intentos: int, n: int) -> float:
    secuencia_de_intentos = random.randint(1, 7, (numero_de_intentos, numero_de_tiros, numero_de_dados))
    sumatoria_de_dados = sum(secuencia_de_intentos, axis=2)
    tiros_con_n = sum(sumatoria_de_dados == n)
    probabilidad_de_n = tiros_con_n / numero_de_intentos
    return probabilidad_de_n


if __name__ == '__main__':
    numero_de_dados = 2  # int(input('Cuantos dados: '))
    numero_de_tiros = 10  # int(input('Cuantas tiros del dado: '))
    numero_de_intentos = 100000000  # int(input('Cuantas veces correra la simulacion: '))
    n = 12  # int(input('Cual sera el evento a evaluar: '))

    probabilidad_de_n = main(numero_de_tiros, numero_de_dados, numero_de_intentos, n)

    print(f'Probabilidad de obtener por lo menos un {n} en {numero_de_tiros} tiros = {probabilidad_de_n}')
    print(f'Tiempo transcurrido = {time.perf_counter()} segundos')

Lo que hice no puede ser lo mas optimo pero fue lo que mas rapido se me ocurrio jajaj

igual aqui dejo mi solucion

import random


def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []
    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def suma_dados(tiros_dado_1, tiros_dado_2):
    suma = []
    for i in range(len(tiros_dado_1)):
        for j in range(len(tiros_dado_1[i])):
            suma.append(tiros_dado_1[i][j] + tiros_dado_2[i][j])
    return suma

def main(numero_de_tiros, numero_de_intentos):
    tiros_dado_1 = []
    tiros_dado_2 = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros_dado_1 = tirar_dado(numero_de_tiros)
        secuencia_de_tiros_dado_2 = tirar_dado(numero_de_tiros)
        tiros_dado_1.append(secuencia_de_tiros_dado_1)
        tiros_dado_2.append(secuencia_de_tiros_dado_2)

    suma = suma_dados(tiros_dado_1, tiros_dado_2)

    tiros_con_12 = 0
    for i in suma:
        if i == 12:
            tiros_con_12 += 1

    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en {numero_tiros} tiros = {probabilidad_tiros_con_12}')


if __name__ == '__main__':

    numero_tiros = int(input('Tiros del dado: '))
    numero_de_intentos = int(input('Introduce el numero de intentos: '))
    main(numero_tiros, numero_de_intentos)```

Comparto mi código para el reto, y la solución me da una probabilidad de 0.245.

import random

def dado():
    return random.choice([1, 2 ,3 ,4 ,5 ,6])


def tirar_dados(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        secuencia_de_tiros.append((dado(), dado()))
        
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    # print(tiros_1)
    # print(tiros_1[0])

    tiros_con_12 = 0
    for tiro in tiros:
        # print(tiro)
        result = list(map(lambda x: x == (6, 6), tiro))
        # print(sum(result))
        if sum(result):
            tiros_con_12 +=1

    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')


if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos)

Yo lo que hice fue generalizar un poco más el caso haciendo que el main recibiera el número de dados a lanzar y el resultado esperado:

if __name__ == '__main__':
    number_of_dices = int(input('How many dices: '))
    number_of_times = int(input('How many times throw the dices: '))
    number_of_simulations = int(input('How many times run the simulation: '))
    number_expected = int(input('Number expecting to get: '))

    main(number_of_times, number_of_simulations, number_of_dices, number_expected)

Tengo una clase Dado con un método lanzar dado que hace el random choice

class Dice():
    def __init__(self):
        pass
    def throw_dice(self):
        return random.choice([1,2,3,4,5,6])

La función tirar dado la renombré como simulate (porque me confundía el nombre) y ahora recibe un arreglo de dados.
En lugar de hacer el random choice directo ahora llama a la función throw_dices / lanzar dados que regresa la suma de tirar los dados

def simulate(number_of_times, dices):
    dice_results = []
    for _ in range(number_of_times):
        #dice_result = random.choice([1,2,3,4,5,6])
        sum_of_dices = throw_dices(dices)
        dice_results.append(sum_of_dices)
    return dice_results

Y la función throw_dices llama al método throw_dices de cada Dado y suma sus resultados. Al final retorna esa suma

def throw_dices(dices):
    sum_of_dices = 0
    for dice in dices:
        dice_result = dice.throw_dice()
        sum_of_dices += dice_result
    return sum_of_dices

La función main instancia los dados recibidos por parametro y llama a la función simulate (antes tirar_dado).
Lo demás es básicamente el mismo código del profesor.

def main(number_of_times, number_of_simulations,number_of_dices, number_expected):
    simulations_results = []
    dices = []
    for _ in range(number_of_dices):
        dices.append(Dice())
    
    for _ in range(number_of_simulations):
        dice_results = simulate(number_of_times, dices)
        simulations_results.append(dice_results)

    throwings_with_number_expected = 0
    for one_simulation in simulations_results:
        #if 1 in one_simulation:
        if number_expected in one_simulation:
            throwings_with_number_expected += 1
    throwings_with_1_probability = throwings_with_number_expected / number_of_simulations
    print(f'Probability of get at least a {number_expected} in {number_of_times} throwings with {number_of_dices} is: {throwings_with_1_probability}')

Por último la probabilidad que me resultó para obtener un 12 al lanzar 2 dados 10 veces y realizando 5,000 simulaciones fue aproximadamene 0.24574

Los cambio que hay que hacer:

def tirar_dado(numero_tiros):
	secuencia_tiros = []
	for _ in range(numero_tiros):
		tiro1 = random.choice([1,2,3,4,5,6])
		tiro2 = random.choice([1,2,3,4,5,6])
		secuencia_tiros.append(tiro1+tiro2)

	return secuencia_tiros

y evaluar la probabilidad

tiros_con_12 = 0
	for tiro in tiros:
		if 12 in tiro:
			tiros_con_12 += 1
	probabilidad_12 = tiros_con_12 / numero_intentos
	print(f'La probabilidad de obtener por lo menos un 12 en {numero_tiros} tiros es = {probabilidad_12}')

resultado:

aqui esta, aunque creo que estoy usando un O(n2) por tratar de hacer mas compleja la solucion.**

Mi solución comentada al reto: aquí

Solución del reto con dos dados ( calcula la probabilidad de obtener un 12):

import random

def tirar_dados(numero_de_tiros):
	secuencia_de_tiros = []

	for _ in range (numero_de_tiros):
		tiro_d1 = random.choice([1,2,3,4,5,6])
		tiro_d2 = random.choice([1,2,3,4,5,6])
		tiro = tiro_d1 + tiro_d2
		secuencia_de_tiros.append(tiro)

	return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
	tiros = []

	for _ in range (numero_de_intentos):
		secuencia_de_tiros = tirar_dados(numero_de_tiros)
		tiros.append(secuencia_de_tiros)

	tiros_con_12 = 0
	for tiro in tiros:
		if 12 in tiro:
			tiros_con_12 += 1
	probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
	print(f'La probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros es = {probabilidad_tiros_con_12}')


if __name__ == '__main__':
	numero_de_tiros = int(input('Cuantos tiros del dado desea: '))
	numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

	main(numero_de_tiros, numero_de_intentos) ```


La probabilidad de tirar 2 dados y que la suma de estos de 12.

import random

def tirar_dado(numero_de_tiros):

    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro_1 = random.choice([1,2,3,4,5,6])
        tiro_2 = random.choice([1,2,3,4,5,6])
        tiro = tiro_1 + tiro_2
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):

    tiros= []

    for _ in range(numero_de_intentos):

        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0

    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')


if __name__ == '__main__':

    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos)

El código es muy parecido, solo se hizo un pequeño cambio, dando como resultado lo siguiente:
(

Antes de esta clase yo lo implemente de esta forma
Simple y fácil de ver la idea de probabilidades

import random
def dado(n,iteraciones):
    count = 0
    for _ in range(iteraciones):
        x = random.choice([(1),(2),(3),(4),(5),(6)])
        if x == n:
            count += 1
    return count

contador = 10000
x = dado(1,contador)

print(f"Numero de veces {x} en {contador}")

probabilidad de 0.24 a alguien le salió parecido?

Lo que hice fue iterar mas veces cuando hay mas dados

import random

def tirar_dado(numero_de_tiros, numero_de_dados):
    secuencia_de_tiros = list()
    for _ in range(numero_de_tiros):
        for __ in range(numero_de_dados):
            tiro = random.choice([1,2,3,4,5,6])
            secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos, numero_de_dados):
    tiros = list()
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros, numero_de_dados)
        tiros.append(secuencia_de_tiros)
    
    tiros_con_1 = 0
    for tiro in tiros:
        if 1 in tiro:
            tiros_con_1 += 1
    probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 1 en {numero_de_tiros} tiros con {numero_de_dados} dados es: {probabilidad_tiros_con_1}')
    

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces quiere correr la simulación: '))
    numero_de_dados = int(input('Cuantos dados quieres tirar: '))

    main(numero_de_tiros, numero_de_intentos, numero_de_dados)```
  • La probabilidad de NO obtener un 12 en un tiro con dos dados es = (35/36)
  • La probabilidad de NO obtener un 12 en 10 tiros con dos dados es =(35/36)^10 = 0.7545
  • La probabilidad de SI obtener un 12 en 10 tiros con dos dados es = (1-0.7545) = 0.2455
<h4>Este Codigo sirve para obtener la probabilidad e cualquier resultado, por ejemplo: obtener un 7 en 10 tiros</h4>
  • La probabilidad de NO obtener un 7 en un tiro con dos dados es = (6/36)
  • La probabilidad de NO obtener un 7 en 10 tiros con dos dados es = (30/36)^10 = 0.8333
  • La probabilidad de SI obtener un 7 en 10 tiros con dos dados es = (1-0.8333) = 0.1667
import random

def tirar_dado(number_of_attemps, number_of_dice=1):    
    secuencia_de_tiros = []
    for _ in range(number_of_attemps):
        tiro = 0
        for _ in range(number_of_dice):
            tiro += random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(number_of_attemps, number_simulations, number_of_dice=1, target_value=1, probability_type=0):
    tiros = []
    for _ in range(number_simulations):
        secuencia_de_tiros = tirar_dado(number_of_attemps, number_of_dice)
        tiros.append(secuencia_de_tiros)

    tiros_con = 0
    tiros_sin = 0
    for tiro in tiros:
        if probability_type == 0:
            if target_value not in tiro:
                tiros_sin += 1
        elif probability_type == 1:
            if target_value in tiro:
                tiros_con += 1
        

    probabilidad_tiros_con = tiros_con / number_simulations
    probabilidad_tiros_sin = tiros_sin / number_simulations
    print(f'Probabilidad de {"no" if probability_type==0 else "si"} obtener por lo menos un {target_value} en {number_of_attemps} tiros = {probabilidad_tiros_con if probability_type==1 else probabilidad_tiros_sin}')



if __name__ == '__main__':
    number_of_attemps = int(input('Cuantos tiros del dado: '))
    number_simulations = int(input('Cuantas veces correra la simulacion: '))
    number_of_dice = int(input('Cuantos Dados Tienes: '))
    target_value = int(input('Valor Objetivo: '))
    probability_type = int(input('Tipo de probabilidad 1=Obtener Valor Objetivo / 0=No Obtener Valor Objetivo: '))

    main(number_of_attemps, number_simulations, number_of_dice, target_value, probability_type)

Es interesante este ejercicio de probabilidad. Para encontrar la respuesta analítica se debe usar la función de probabilidad de la distribución binomial (simplemente hay que usar la formula).
La probabilidad de que nunca salga un 12 es 0.754
La probabilidad de que salga al menos una vez es 1-0.754 = 0.246
La probabilidad de que salga 12 solamente una vez es 0.216. Incluyo esta probabilidad solamente porque me hace entender mejor la pregunta

La rutina de simulación sigue los dos primeros pasos y es bastante aproximada. En mi caso fue 0.242 con 10000 simulaciones.

import random

def tirar_dados(numero_de_tiros):

secuencia_de_tiros = []

for _ in range(numero_de_tiros):

    tiro1 =random.choice([1,2,3,4,5,6])
    tiro2 =random.choice([1,2,3,4,5,6])
    # otra manera de ponerlo : random.ranint([1])
    secuencia_de_tiros.append(tiro1+tiro2)

return secuencia_de_tiros

def main(numero_de_tiros,numero_de_intentos):
#arreglo vacio significa que nosotros vamos a llenar la tupla
tiros = []

for _ in range(numero_de_intentos):

    secuencia_de_tiros=tirar_dados(numero_de_tiros)
    tiros.append(secuencia_de_tiros)

tiros_con_12 = 0
for tiro in tiros:
    if 12 in tiro:
        tiros_con_12 += 1

probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')

if name == ‘main’:

numero_de_tiros = int(input('Cuantos tiros del dado: '))
numero_de_intentos = int(input('Cuantas veces correra la simulación: '))

main(numero_de_tiros,numero_de_intentos)

En este código, el usuario ingresa el valor a buscar en un rango de 2 - 12 (posibles valores de 2 dados), el mismo código manda un mensaje de error cuando un se ingresa un valor imposible de calcular. Posteriormente hace el cálculo de los 2 dados, simplemente utilice 2 veces la función random.choice para generar el número

Aqui les dejo el código:

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6]) + random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros


def main(valor_buscado, numero_de_tiros, numero_de_intentos):
    tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_n = 0

    for tiro in tiros:
        if valor_buscado in tiro:
            tiros_con_n += 1

    probabilidad = tiros_con_n / numero_de_intentos
    print(f'Probabilidad de no obtener {valor_buscado} en {numero_de_tiros}: {probabilidad}')


if __name__ == "__main__":
    valor_buscado = 0

    while valor_buscado == 0:
        valor_buscado = int(input('Valor de los dos dados: '))

        if valor_buscado <= 1 or valor_buscado >= 13:
            print(f'El valor {valor_buscado} en los dados es imposible de calcular')
            valor_buscado = 0

    numero_de_tiros = int(input('Tiros del Dado: '))
    numero_de_intentos = int(input('Numero de intentos: '))

    main(valor_buscado, numero_de_tiros, numero_de_intentos)

RETO:

Teoría
Vi la tabla construida por el compañero @ItaloQuevedo que tiene como probabilidad 1/36 el obtener un 12 con dos dados. Entonces sacar un 12 en al menos 10 tiros es
P(obtener 12 u obtener 12 u obetener 12 …) = 10*P(obtener 12) = 10/36 = 0.2777777 = 27%

Simulación
Corriendo un nuevo ‘main’ que llamé ‘reto’ y utilizando las función ‘tirar_dado’ del código del profe:

def reto(numero_de_tiros, numero_de_intentos):
    tiros_de_dos_dados = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros_1 = tirar_dado(numero_de_tiros)
        secuencia_de_tiros_2 = tirar_dado(numero_de_tiros)
        zip_secuencias = zip(secuencia_de_tiros_1, secuencia_de_tiros_2)
        secuencia_de_dos_dados = [tiro_1 + tiro_2 for (tiro_1, tiro_2) in zip_secuencias]
        tiros_de_dos_dados.append(secuencia_de_dos_dados)

    tiros_con_12 = 0
    for tiro_doble in tiros_de_dos_dados:
        if 12 in tiro_doble:
            tiros_con_12 += 1

    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de al menos un 12 en {numero_de_tiros} tiros dobles = {probabilidad_tiros_con_12}')

Queda:

Me da entonces un error de aproximadamente 0.03 (o 3% de probabiilidad) Vs la teoría.

Ese es mi codigo graficando las probailidades:

import random
from bokeh.plotting import figure, show

def tirar_dado(numero_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros    

def graficar(x, y, tiros, intentos):
    titulo = f'Probabiliades de {tiros} tiros en {intentos} intentos'
    grafica = figure(title = titulo, x_axis_label = 'Intentos')
    grafica.circle(x, y, legend_label = 'Probabilidad', size = 1)
    grafica.line(x, y)
    show(grafica)

def main(numero_tiros, numero_intentos):
    tiros = []
    for _ in range(numero_intentos):
        secuencia_de_tiros = tirar_dado(numero_tiros)
        tiros.append(secuencia_de_tiros)
    tiros_con_uno = 0
    intento = 1
    probabilidades = []
    for tiro in tiros:
        if 1 not in tiro:
            tiros_con_uno += 1
        probabilidades.append(tiros_con_uno/intento)
        intento +=1
    probabildad_tiros_con_1 = tiros_con_uno / numero_intentos
    x_ilum = list(range(numero_intentos))
    y_ilum = probabilidades
    print(f'La probabilidad de no obtener al menos un uno en {numero_tiros} tiros es {probabildad_tiros_con_1}')
    graficar(x_ilum, y_ilum, numero_tiros, numero_intentos) 

if __name__ == '__main__':
    numero_tiros = int(input('Cuantos tiros del dado: '))
    numero_intentos = int(input('Cuantas veces correra la simulacion?: '))
    main(numero_tiros, numero_intentos)

Este es un ejemplo de la grafica:

Este es mi código para encontrar un 12, lo implementé en Julia ✨

function throw_dice(throws_number)
  throw_sequence = Int64[]
  for i ∈ 1:throws_number
    throw = rand(1:6)
    push!(throw_sequence, throw)
  end
  return throw_sequence 
end

function main()
  # Obtener un 12 con dos dados, y 10 tiros
  throws_number = 1
  attempts_number = 10000
  throws = []
  one_counter = 0
  # The more population tests, the more accurate the simulation is
  for i ∈ 1:attempts_number
    throw_sequence = throw_dice(throws_number)
    second_throw_sequence = throw_dice(throws_number)
    append!(throw_sequence, second_throw_sequence)
    push!(throws, throw_sequence)
    # Count if there's a 12 in two dices
    if count(x -> x == 6, throw_sequence) == 2
      one_counter += 1
    end
  end
  println("Number of a twelve is found: $one_counter - Number of attempts: $attempts_number")
  probability = one_counter/attempts_number
  println("Probability of getting a twelve: $probability")
end

main()

comparto mi código, le agregue que el usuario pueda escoger el numero de dados y el numero al que quiere calcular la probabilidad.

import abc
import random

def tirar():
    tiro = random.choice([1, 2, 3, 4, 5, 6])
    return tiro

def jugada(cantDados):
    tiro = 0
    for _ in range(cantDados):
        tiro = tiro + tirar()
    return tiro

def dados(cantDados, numIntentos):
    secuenciaTiros = []
    tiro = 0
    for _ in range(numIntentos):
        tiro = jugada(cantDados)
        secuenciaTiros.append(tiro)
    return secuenciaTiros

def simulaciones(cantDados, numIntentos, numSimulaciones):
    simulacion = []
    for _ in range(numSimulaciones):
        secuenciaTiros = dados(cantDados, numIntentos)
        simulacion.append(secuenciaTiros)
    # print(simulacion)
    return simulacion
        
def probabilidades(simulacion, probabilidad):
    intentos = 0
    for i in simulacion:
        if probabilidad in i:
            intentos += 1
            # print(f'en la simualacion {i} hay por lo menos un {probabilidad}')
    
    return intentos

if __name__=='__main__':
    # cantDados = int(input('Numero de dados que quieres tirar: '))
    # numIntentos =  int(input('Numero de intentos que quieres tirar: '))
    # numSimulaciones = int(input('Numero de simulaciones que quieres hacer: '))
    # probabilidad = int(input('Hallar la probabilidad que salga el numero: '))
    # simulacion = []
    # simulacion = simulaciones(cantDados, numIntentos, numSimulaciones)
    simulacion = simulaciones(2,10,1000) 
    resultado = probabilidades(simulacion, 12) / 1000
    # resultado = probabilidades(simulacion, probabilidad) / numSimulaciones
    # print(f'la probabilidad de hallar un {probabilidad} en {numIntentos} intentos con {cantDados} dados es: {resultado}')
    print(f'la probabilidad de hallar un 12 en 10 intentos con 2 dados es: {resultado}')

El reto del profe escrito en Rust
usando las librerias:
rand = "0.8.4"
ansi_term = "0.12"
en Cargo.toml

#[warn(non_snake_case)]
pub(crate) use rand::Rng;
use ansi_term::Colour;


fn dices_shots(n_shots: u32) -> (Vec<u32>, Vec<u32>) { // Returns a list with random numbers with len(n)
    let mut sequence_shots_1 = Vec::new();
    let mut sequence_shots_2 = Vec::new();
    let mut rng = rand::thread_rng();

    for _ in 0..n_shots {
        let shot: u32 = rng.gen_range(1..=6);
        sequence_shots_1.push(shot);
    }
    for _ in 0..n_shots {
        let shot: u32 = rng.gen_range(1..=6);
        sequence_shots_2.push(shot);
    }
    return (sequence_shots_1, sequence_shots_2);
}


fn run_simulation(n_shots: u32, n_attempts: u32) {
    let mut shots = Vec::new();
    let ref mark: u32 = 12; // Dice Number to find 
    let mut shots_with: u32 = 0;

    for i in 0..n_attempts {
        let (sequence_1, sequence_2): (Vec<u32>, Vec<u32>) = dices_shots(n_shots);
        println!("{} -> {}", 
        Colour::Green.bold().paint("Collecting data"), 
        Colour::Yellow.paint(format!("{}", i)));

        let new_senquence = {
            let mut new_s: Vec<u32> = Vec::new();
            for i in sequence_1.iter().zip(sequence_2.iter()) {
                let (s1, s2) = i;
                println!("First Dice: {}, Second Dice: {}, Result: => {}", s1, s2, (*s1 + *s2));
                new_s.push(*s1 + *s2);
            }
            new_s
        };
        shots.push(new_senquence);

    }
    for shot in shots.iter() {
        if shot.contains(mark) {
            shots_with += 1;
        }
    }
    println!("------ {} ------", Colour::Yellow.bold().paint("All data collected"));
    for i in shots.iter() {
        println!("{}", Colour::Yellow.paint(format!("{:?}", i)));
    }

    println!("\n\n------ {} ------\n", Colour::Green.bold().paint("Results"));
    println!("There were {} arrays containing {} with {} attempts.\n (With two dices)\n", 
    Colour::Green.bold().paint(format!("{}", shots_with)),
    Colour::Green.bold().paint(format!("{}", mark)),
    Colour::Green.bold().paint(format!("{}", n_attempts)));

    let probability: f32 = shots_with as f32 / n_attempts as f32;
    println!("{}{:.10}", Colour::Green.bold().paint("Probability: "), probability);
}   


fn main() {
    let (n_shots, n_attempts): (u32, u32) = (10, 100000);
    run_simulation(n_shots, n_attempts);
}

Es de los primeros códigos que logro casi desde 0 y seguramente lo complique más de la cuenta, también lo hice pensando en ingles según el consejo del profesor, este fue el resultado en consola:

Con esta función obtengo la suma de la tirada de n dados

def sum_per_throw(dices):
    
    sub_total = 0
    
    for _ in range(dices):
        sub_total = sub_total + random.choice([1,2,3,4,5,6])
    
    # print(f'sum_per_throw = {sub_total}')
    return sub_total

acá obtengo la cantidad de veces que los dados dieron la cantidad buscada por cada ronda

def ocurrences_per_round(throws, dices, sum_number):
    occurrences_p_r = 0

    for _ in range(throws):
        if sum_per_throw(dices) == sum_number:
            occurrences_p_r += 1
    
    # print(f'ocurrences_per_round = {occurrences_p_r}')
    return occurrences_p_r

y acá el número de veces que ocurre en todas las rondas

def occurrences_per_sample(r_throws, dices_n, d_sum_number, t_rounds):
    occurrences_p_s = 0

    for round in range(t_rounds):
        occurrences_p_s = occurrences_p_s + ocurrences_per_round(r_throws, dices_n, d_sum_number)
    
    # print(f'ocurrences per sample: {occurrences_p_s}')
    return occurrences_p_s   

mi función main

def main(round_throws, dices_number, dices_sum_number, total_rounds):
    times = occurrences_per_sample(round_throws, dices_number, dices_sum_number, total_rounds)
    print("*" * 50)
    print(f'using {dices_number} dices, and throwing {round_throws} times per round, for {total_rounds} rounds,') 
    print(f'we can get {times} occurrences of totaling {dices_sum_number}')
    print(f'Then, the probability of obtaining {dices_sum_number} is {times/(round_throws * total_rounds)}')
    print("*" * 50)

y mi punto de inicio

if __name__ == '__main__':
    dices_number = int(input('how many dices are we using? '))
    dices_sum_number = int(input('What number are we looking for? '))
    round_throws = int(input('How many times are we throwing per round? '))
    total_rounds = int(input('How many rounds will we try? '))

    main(round_throws, dices_number, dices_sum_number, total_rounds)

Cuantos tiros del dado: 10
Numero de simulaciones: 5000
Numero de dados: 2
Numero de caras de los dados: 6
Probabilidad de no obtener por lo menos un 12 en 10 tiros = 0.25

import random

def tirar_dado(numero_de_caras):
    return random.randint(1,numero_de_caras)

def tirar_dados(numero_de_tiros,numero_de_dados,numero_de_caras):
    secuencia_de_tiros=[]
    for _ in range(numero_de_tiros):
        tiro = 0
        for _ in range(numero_de_dados):
            tiro = tiro + tirar_dado(numero_de_caras)

        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros

def main(numero_de_tiros,numero_de_intentos,numero_de_dados,numero_de_caras):
    tiros=[]

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dados(numero_de_tiros,numero_de_dados,numero_de_caras)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    probabilidad_tiros_con_1 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de no obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_1}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Numero de simulaciones: '))
    numero_de_dados = int(input('Numero de dados: '))
    numero_de_caras = int(input('Numero de caras de los dados: '))
    main(numero_de_tiros,numero_de_intentos,numero_de_dados,numero_de_caras)

Hola Compañeros, aquí les dejo mi respuesta, yo lo hice lo más sencillo que se me ocurrió, incluir un segundo dado y sumar los dos. Queda muy parecido.

Si alguien me puede recomendar donde tomar un curso de estadística más a profundidad, para entender mejor las probabilidades se lo agradecería

import random

def simulador_tiro(numero_de_tiros):
tiradas = []

for _ in range(numero_de_tiros):
    tiro = random.choice([1, 2, 3, 4, 5, 6])
    tiro2 = random.choice([1, 2, 3, 4, 5, 6])#Incluí este "tiro2" como el segundo dado
    tiradas.append(tiro + tiro2)#Aquí se hace la suma de los dados 1 y 2

return tiradas

def main(numero_de_tiros, numero_de_simulaciones):
tiros = []
hay_12 = 0

for _ in range(numero_de_simulaciones):
    simulacion = simulador_tiro(numero_de_tiros)
    tiros.append(simulacion)

for t in tiros:
    if 12 in t:
        hay_12 += 1

print(f'Se tiro el dado {numero_de_tiros} en {numero_de_simulaciones} ocaciones')
print(f'La posibilidad que salga 12 es de {hay_12/numero_de_simulaciones}')

if name == “main”:

numero_de_tiros = int(input('Introduce el número de tiros: '))
numero_de_simulaciones = int(input('Introduce cuantas veces se va a repetir la simulación: '))

main(numero_de_tiros, numero_de_simulaciones)

Modifique el código para que pregunte cuantos dados quiere tirar el usuario (Entre dos un dado)y además que número quiere para hacerlo un poco más interactivo

Y las respuestas al reto que propuso el profesor es 0.2467 o 24.67%

código modificado para simular que se tiran 2 dados.
tiros = 10
simulado = 100
probabilidad de obtener 12 en 10 tiros = 0.7

Hola, le comparto mi código del ejercicio con la gráfica:

import random
from bokeh.plotting import figure, show

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1,2,3,4,5,6])
        tiro2 = random.choice([1,2,3,4,5,6])
        resultado = tiro + tiro2
        secuencia_de_tiros.append(resultado)

    return secuencia_de_tiros

def plot(sim, prob):
    plot = figure(title = 'probabilidad de obtener por lo menos un 12',
            x_axis_label = 'Numero de intentos',
            y_axis_label = 'Probabilidad')

    plot.line(sim,prob)
    show(plot)

def calc_prob(tiros, numero_de_intentos):
    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1
    return tiros_con_12 / numero_de_intentos

def main(numero_de_tiros, numero_de_intentos):
    sim = []
    prob = []
    for n in range(1,numero_de_intentos,100):
        tiros = []
        for _ in range(n):
            secuencia_de_tiros = tirar_dado(numero_de_tiros)
            tiros.append(secuencia_de_tiros)
        prob_shot_1 =calc_prob(tiros,n)
        prob.append(prob_shot_1)
        sim.append(n)

    plot(sim, prob)
    ultimo = float(prob[-1])
    print(f'probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {ultimo}')


if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulación: '))
    main(numero_de_tiros, numero_de_intentos)




Entre más veces corres una simulación, más te acercas a la respuesta correcta. Explicado por la ley de los grander números. Entre más muestras, más cercanos estamos de que los valores sean exactos.

Para poder calcular de una forma eficiente y sencilla, la probabilidad de muchos casos. Tenemos que plantear bien el problema y sus opciones.

Yo modifique el codigo dado por el profesor, trate de hacerlo un poco mas entendible, al menos para mi, en el podran ver la simulacion y la probabilidad real de que aparezca 12 al tirar 2 dados:

 import random


def tirarDado(numero_de_tiros):
    tiros = []
    for _ in range(numero_de_tiros):
        tirar_2_dados = (random.choice([1,2,3,4,5,6])+random.choice([1,2,3,4,5,6]))
        tiros.append(tirar_2_dados)
    return tiros


def main():
    numero_de_tiros = 1000
    numero_de_intentos = 1000
    secuencia_de_tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros.append(tirarDado(numero_de_tiros))
    
    tiros_de_12 = 0
    for tiros in secuencia_de_tiros:
        tiros_de_12 += tiros.count(12)

    probabilidad_tiros_12 = tiros_de_12 / (numero_de_tiros*numero_de_intentos)

    print(f"""
    =========SIMULACION============
    Tiros que salieron 12: {tiros_de_12}
    Total de tiros: {numero_de_tiros*numero_de_intentos}
    Probabilidad de que un tiro salga en 12: {probabilidad_tiros_12}
    =========SIMULACION============
    """)

    dado_1 = [1,2,3,4,5,6]
    dado_2 = [1,2,3,4,5,6]
    total_de_12 = 0
    total_posibilidades = 0

    for num1 in dado_1:
        for num2 in dado_2:
            if num1+num2 == 12:
                total_de_12 += 1
            total_posibilidades +=1
    
    print(f"Probabilidad REAL de sacar un 12 tirando 2 dados: {total_de_12/total_posibilidades}")

if __name__ == "__main__":
    main()

Mi resultado fue que se aproxima al 2.7%


import random

def run():
    numero_de_tiros = int(input("Cuantas veces debe tirar los dados: "))
    repetir_tiro = int(input("Cuantas veces deseas realizar la prueba: "))

    calculo_probabilidades(numero_de_tiros, repetir_tiro)



def calculo_probabilidades(numero_de_tiros, repetir_tiro):
    p12 = 0
    resultado = list(repetir_operacion(numero_de_tiros, repetir_tiro))
    for i in resultado:
        for p in i:
            if p == 12:
                p12 += 1
            
    p12 = (round(p12 / (len(resultado) * numero_de_tiros), 8))*100

    print("la probabilidad de que de {} tiros de un dado salga 12 es de {}%".format(numero_de_tiros, p12))


def repetir_operacion(numero_de_tiros, repetir_tiro):
    resultados = []
    for _ in range(repetir_tiro):
        resultados.append(tirar_repetidamente(numero_de_tiros))

    return resultados

def tirar_repetidamente(numero_de_tiros):
    tiro = []
    for _ in range(numero_de_tiros):
        a = tirar_dado()[0]
        b = tirar_dado()[1]
        tiro.append(a + b)

    return tiro


def tirar_dado():
    return list((random.choice([1, 2, 3, 4, 5, 6]), random.choice([1, 2, 3, 4, 5, 6])))



if __name__ == '__main__':
    run()

Este es el resultado del reto, espero este bien.

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros_uno = []
    for _ in range(numero_de_tiros):
        tiro = random.choice([1,2,3,4,5,6])
        secuencia_de_tiros_uno.append(tiro)
    return secuencia_de_tiros_uno


def main(numero_de_tiros, numero_de_intentos):
    tiros_dado_uno = []
    tiros_dado_dos = []
    probabilidad_tiros_con_12 = 0
    tiros_con_12 = 0


    for _ in range(numero_de_intentos):
        secuencia_de_tiros_dado_uno = tirar_dado(numero_de_tiros)
        tiros_dado_uno.append(secuencia_de_tiros_dado_uno)
        secuencia_de_tiros_dado_dos = tirar_dado(numero_de_tiros)
        tiros_dado_dos.append(secuencia_de_tiros_dado_dos)
        if 6 in secuencia_de_tiros_dado_uno and 6 in secuencia_de_tiros_dado_dos:
            tiros_con_12 += 1
        
    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print("Probabilidad de obtener 12: ", probabilidad_tiros_con_12)

    
if __name__ == '__main__':
    numero_de_tiros = int(input("Cuantas veces quieres tirar el dado?: "))
    numero_de_intentos = int(input("Cuantas veces quieres repetir la simulacion?: "))
    main(numero_de_tiros, numero_de_intentos)
 
import matplotlib.pyplot as plt
import random

def throw_diece(n_trows):
    return [random.randint(1, 6) for i in range(n_trows)]


def find_probability(number, n_throws):
    diece_1 = throw_diece(n_throws)
    diece_2 = throw_diece(n_throws)
    results = list(map(lambda x: x[0] + x[1], zip(diece_1, diece_2)))
    return results.count(number) / n_throws

def steps(start, final, n, step):
    return start + (final -  start) / (n-1) * step

def main(): 
    n_tries = int(input('Please input the number of tries: '))
    tries = []
    number = 6
    n_throws = int(input('Please input the numbers of diece throws: '))
    
    for i in range(n_tries):
        p_1 = find_probability(number, n_throws)
        tries.append(p_1)
      

    mu = sum(tries) / n_tries
    print('the mu is', mu)


if __name__ == '__main__': 
    main()

Les comparto mi solución al problema. Redacté una función para calcular la probabilidad. Además, utilicé iteraciones para poder **realizar un tiro de un dado la n cantidad **de veces que se establezce. El valor a encontrar también es declarado en una variable.

import random

# RETO DE  DOS DADOS
# PROBABILIDAD DE OBTENER UN 12 EN MÍNIMO 10 TIROS

def probabilidad(valor, tiros, numero_de_tiros):
    tiros_con_valor = 0
    
    for tiro in tiros:
        if valor in tiro:
            tiros_con_valor += 1
                    
    probabilidad_de_tiros  = tiros_con_valor / numero_de_intentos
    print(f'La probabilidad de no obtener un {valor} en {numero_de_tiros} tiros, es igual a la {probabilidad_de_tiros}')     

def tirar_dado(numero_de_tiros, dados):
    secuencia_de_tiros = []
    for _ in range(numero_de_tiros):
        sumatoria = 0
        for dado in range(dados):
            tiro = random.choice([1, 2, 3, 4, 5, 6])
            sumatoria += tiro
        #random.randint(1,7)
        secuencia_de_tiros.append(sumatoria)
        
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos, dados, valor):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros, dados)
        tiros.append(secuencia_de_tiros)
    
    probabilidad(valor, tiros, numero_de_tiros)


if __name__ == '__main__':
    
    numero_de_tiros = int(input('Tiros del dado: '))
    # Ley de los grandes números
    numero_de_intentos = int(input('Número de intentos: '))
    dados = 2
    valor = 12
    
    main(numero_de_tiros, numero_de_intentos, dados, valor)

Aquí creé un objeto llamado dado, lo creé con 8 caras, lo tiré 100000 veces e hice una grafica de barras de las probabilidades de salir cada cara, como lo es de esperarse, salió que son bastante parecidas todas a 1/8.

import random
import matplotlib.pyplot as plt
import numpy as np

class Dice:
    def __init__(self, n_sides=6):
        self.n_sides = n_sides
        
    def roll(self):
        return random.randint(1, self.n_sides)
    
if  __name__ == '__main__':
    n_sides = 6
    n_rolls = 100000
    dado = Dice(n_sides)
    dice_rolls = {}
    
    for i in range(1,n_sides+1):
        dice_rolls[i] = 0
    
    for _ in range(n_rolls):
        roll = dado.roll()
        dice_rolls[roll] += 1
    
    names = np.array(list(dice_rolls.keys()))
    values = np.array(list(dice_rolls.values()))
    plt.bar(names, values)
    plt.title('Dice rolls results')
    plt.show()
    
    plt.bar(names, values/n_rolls)
    plt.title('Dice probablilities')
    plt.show()
import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros


def main(numero_de_tiros, numero_de_dados, numero_de_intentos, suma_encontrar):
    tiros = []
    for _ in range(numero_de_intentos):
        sum_list = []
        for i in range(numero_de_dados):
            list_tiros = tirar_dado(numero_de_tiros)
            if i == 0:  
                for value in list_tiros:
                    sum_list.append(value)
            else:
                for i, value in enumerate(list_tiros):
                    sum_list[i] += value
        tiros.append(sum_list)

    cuenta_tiros = 0
    for tiro in tiros:
        if suma_encontrar in tiro:
            cuenta_tiros += 1

    probabilidad_tiros = cuenta_tiros / numero_de_intentos
    print(
        f'Probabilidad de obtener por lo menos un {suma_encontrar} en {numero_de_tiros} tiros = {probabilidad_tiros} con {numero_de_dados} dados')


if __name__ == '__main__':
    # numero_de_tiros = int(input('¿Cuántos tiros del dado?: '))
    # numero_de_intentos = int(input('¿Cuántas veces correrá la simulación? '))
    numero_de_tiros = 10
    numero_de_dados = 2
    numero_de_intentos = 10000
    suma_encontrar = 12
    

    main(numero_de_tiros, numero_de_dados, numero_de_intentos, suma_encontrar)

Les comparto mi versión
Para obetener la probabilidad de una suma, de una cantidad n de dados

import random
from itertools import zip_longest


def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros


def main(numero_de_tiros, numero_de_dados, numero_de_intentos, suma_encontrar):
    tiros = []
    for _ in range(numero_de_intentos):
        sum_list = []
        for i in range(numero_de_dados):
            list_tiros = tirar_dado(numero_de_tiros)
            if i == 0:  
                for value in list_tiros:
                    sum_list.append(value)
            else:
                for i, value in enumerate(list_tiros):
                    sum_list[i] += value
        tiros.append(sum_list)

    cuenta_tiros = 0
    for tiro in tiros:
        if suma_encontrar in tiro:
            cuenta_tiros += 1

    probabilidad_tiros = cuenta_tiros / numero_de_intentos
    print(
        f'Probabilidad de obtener por lo menos un {suma_encontrar} en {numero_de_tiros} tiros = {probabilidad_tiros} con {numero_de_dados} dados')


if __name__ == '__main__':
    # numero_de_tiros = int(input('¿Cuántos tiros del dado?: '))
    # numero_de_intentos = int(input('¿Cuántas veces correrá la simulación? '))
    numero_de_tiros = 10
    numero_de_dados = 2
    numero_de_intentos = 10000
    suma_encontrar = 12
    

    main(numero_de_tiros, numero_de_dados, numero_de_intentos, suma_encontrar)

La resolucion del reto a fin de clase

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    suma_de_tiros = []
    secuencia_de_tiros_1=0
    secuencia_de_tiros_2=1
    for _ in range(numero_de_intentos):
        secuencia_de_tiros_1 = tirar_dado(numero_de_tiros)
        print(secuencia_de_tiros_1)

        secuencia_de_tiros_2 = tirar_dado(numero_de_tiros)
        print(secuencia_de_tiros_2)
        
        for i in range(len(secuencia_de_tiros_1)):
            suma_tmp = 0
            suma_tmp = secuencia_de_tiros_1[i] + secuencia_de_tiros_2[i]
            print(suma_tmp)
            
            suma_de_tiros.append(suma_tmp)
        
    tiros.append(suma_de_tiros)
        
    print(tiros)          
                
            
            
    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    print(tiros_con_12)

    probabilidad_tiros_con_1 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener 12 como suma de ambos dados en {numero_de_tiros} tiros = {probabilidad_tiros_con_1}')



if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantas tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos)

Aquí comparto mi respuesta!


import random

def tirar_dados(numero_tiros):

    secuencia_de_tiros = []

    for _ in range(numero_tiros):

        tiro_1 = random.choice([1, 2, 3, 4, 5, 6])
        tiro_2 = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro_1+tiro_2)

    return secuencia_de_tiros


def main(numero_tiros, numero_intentos):

    tiros = []
    for _ in range(numero_intentos):

        secuencia_de_tiros = tirar_dados(numero_tiros)
        tiros.append(secuencia_de_tiros)
        # print(tiros)

    tiros_con_12 = 0
    for tiro in tiros:

        if 12 in tiro:

            tiros_con_12 += 1
    
    probabilidad_tiros_con_12 = tiros_con_12 / numero_intentos
    print(f'La probabilidad obtener un tiro que sume 12 en {numero_tiros} tiros es = {probabilidad_tiros_con_12}')

if __name__ == "__main__":

    numero_tiros = int(input("¿Cuántas veces quieres tirar el dado? "))
    numero_intentos = int(input("¿Cuántas veces correra la simulación? "))

    main(numero_tiros, numero_intentos)

A mi código anterior solo le modifiqué las líneas donde tengo doble ## y ya obtuve el código para saber la probabilidad de que al lanzar 2 dados la suma sea 12 en 10 tiros.

def main(simulaciones, tiros):
    k = []
    prob = 0
    for i in range(simulaciones):
        k.append([])
        for j in range(tiros):
            dado_1 = random.randrange(1, 7) ##
            dado_2 = random.randrange(1, 7) ##
            k[i].append(dado_1 + dado_2) ##
        if 12 in k[i]: ##
            prob += 1
    prob = prob / simulaciones
    print(f"La probabilidad es de {prob} en {simulaciones} simulaciones de {tiros} tiros")

if __name__ == '__main__':
    tiros = int(input("Numero de tiros: "))
    simulaciones = int(input("Numero de simulaciones: "))
    main(simulaciones, tiros)

La probabilidad que me arrojó mi código de que la suma de 2 dados de 12 en 1 lanzamiento fue de 0.02717 luego de 100000 simulaciones

Dejo igualmente mi código en el cual se puede buscar la probabilidad de cualquier valor con cualquier cantidad de dados

import random

def lanzar_dado(numero_de_dados):
    tiro = [] #Creamos una lista para guardar los resultados por dado del tiro

    for _ in range(numero_de_dados): #Se realiza un lanzamiento por cada dado
        dado = random.choice([1, 2, 3, 4, 5, 6]) #Se pudo usar también random.randint
        tiro.append(dado) #El resultado por cada lanzamiento de dado se añade a la lista del tiro

    return tiro

def tirar_dados(numero_de_dados, numero_de_tiros):
    tiros = [] #Creamos una lista en la cual se incluya los resultados de los dados por cada tiro
    for _ in range(numero_de_tiros): #Lanza los dados las veces deseadas por simulacion
        tiro = lanzar_dado(numero_de_dados) #Agregar los resultados de los dados por cada tiro a la lista
        tiros.append(tiro)
    return tiros #Retornamos la lista de resultados de todos los tiros

def sumas(numero_de_dados, numero_de_tiros): #Como complicarse la vida al realizar las sumas al final de cada simulacion, en vez de al final de cada tiro
    tiros_a_operar = tirar_dados(numero_de_dados, numero_de_tiros) #Guardamos la lista de los tiros resultantes
    sumas_por_simulacion = [] #Creamos una lista para guardar las sumas de cada tiro
    for tiros in tiros_a_operar: #Por cada tiro
        suma_de_tiro = 0 #iniciaremos a sumar
        for i in tiros: #Separaremos el resultado de cada dado
            suma_de_tiro = suma_de_tiro + i #Lo añadimos a la suma en cuestion
        sumas_por_simulacion.append(suma_de_tiro) #Insertamos el resultado de la suma de cada tiro en la lista de sumas
    return sumas_por_simulacion #de esta funcion, retornamos la lista de las sumas por cada tiro


def main (numero_de_tiros, numero_de_intentos, numero_de_dados):
    sumas_de_tiros = []
    for _ in range(numero_de_intentos): #Ejecutar la simulación la cantidad de veces deseada
        sumas_por_simulacion = sumas(numero_de_dados, numero_de_tiros) #Agregar las sumas resultantes de la simulacion a una lista
        sumas_de_tiros.append(sumas_por_simulacion)

    resultados_deseados = 0 #Contador de veces en el que el resultado deseado aparecio en la simulacion
    for suma in sumas_de_tiros: #Descartamos los escenarios imposibles
        if valor_a_buscar < numero_de_dados or valor_a_buscar > numero_de_dados*6:
            return print ('Este resultado no se puede hayar con esta cantidad de dados')
        else:
            if valor_a_buscar in suma: #El contador crece si el resultado deseado se encuentra en la simulación
                resultados_deseados += 1

    probabilidad = resultados_deseados / numero_de_intentos
    print(f'La probabilidad de al lanzar {numero_de_dados} dados {numero_de_tiros} veces y su suma sea de {valor_a_buscar} es igual a: {probabilidad}')
        
    
if __name__ == '__main__':

    valor_a_buscar = int(input('Valor a buscar: '))
    numero_de_dados = int(input('Numero de dados a usar: '))
    numero_de_tiros = int(input('Tiros a probar: '))
    numero_de_intentos = int(input('Veces a simular: '))
    

    main(numero_de_tiros, numero_de_intentos, numero_de_dados)


Es bastante molesto que el profesor asigne variables o llame funciones que todavia no ha definido. Eso hace que el estudiante se quede perdido.

Intenté utilizar la otra forma de obtener un entero aleatorio y resulta que si es inclusivo el último número dado

 tiro2 = random.randint(1,7)

Esto me daba resultados diferentes a la teoría hasta que imprimí los enteros que me estaban dando.
Lo correcto es

 tiro2 = random.randint(1,6)

La ruleta es un juego de azar típico de los casinos, en una version de ruleta americana la ruleta cuenta con 38 numeros.
He hecho un ejercicio de analizar la probabilidad de que juegue un numero en una ruleta americana en 10000 intentos, como pueden observar la probabilidad es realmente baja. 😃 Para ganar sera cuestion de suerte!

Para graficar utilice bokeh aqui esta documentacion -> https://docs.bokeh.org/en/latest/docs/user_guide/categorical.html

Aquí les dejo mi resultado del reto.

Agradeceré sus comentarios y/o correcciones.

Saludos y gracias

Calcula las probabilidades usando cualquier numero de dados y con cualquier numero que se desee calcular.

  1 import random
  2
  3 def tirar_dados(numero_de_dados, numero_de_tiros):
  4     secuencia_de_tiros = []
  5
  6     for _ in range(numero_de_tiros):
  7         tiros = 0
  8
  9         for _ in range(numero_de_dados):
 10             tiros+= random.choice([1,2,3,4,5,6])
 11
 12         secuencia_de_tiros.append(tiros)
 13
 14     return secuencia_de_tiros
 15
 16 def main(numero_de_dados, numero_de_tiros, numero_de_simulaciones, numero_deseado):
 17     tiros = []
 18     for _ in range(numero_de_simulaciones):
 19         secuencia_de_tiros = tirar_dados(numero_de_dados, numero_de_tiros)
 20         tiros.append(secuencia_de_tiros)
 21
 22     tiros_con_numero_deseado = 0
 23     for tiro in tiros:
 24         if numero_deseado in tiro:
 25             tiros_con_numero_deseado+=1
 26             print(f'{tiros_con_numero_deseado}')
 27
 28     probabilidad_tiros_con_numero_deseado = tiros_con_numero_deseado / numero_de_simulaciones
 29     print(f'Probabilidad de obtener por lo menos un {numero_deseado} en {numero_de_tiros} tiros lanzando {numero_de_dados} dados = {probabilidad_tiros_co    n_numero_deseado}')
 30
 31
 32 if __name__ == '__main__':
 33     numero_de_dados = int(input('Cuantos dados?: '))
 34     numero_de_tiros = int(input('Tiros del dado: '))
 35     numero_de_simulaciones = int(input('Cuantas veces correra la simulacion: '))
 36     numero_deseado = int(input('Numero que deseas?: '))
 37
 38     main(numero_de_dados, numero_de_tiros, numero_de_simulaciones, numero_deseado)

Houston tenemos un problema casi siempre me da 0 pero le veo lógica si ninguno de ellos su suma daba 12

pero si me pueden ayudar a ar solución estaría de perlas

import random


def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []


    for _ in range(numero_de_tiros):
        tiro_1 = random.choice([1, 2, 3, 4, 5, 6])
        tiro_2 = random.choice([1, 2, 3, 4, 5, 6])
        suma_de_tiros = tiro_1 + tiro_2
        secuencia_de_tiros.append(suma_de_tiros)

    return secuencia_de_tiros


def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    
    tiros_con_12 = 0

    for tiro in tiros:
        if 12 in tiro:
           tiros_con_12 += 1

    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')


if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros de dado:  '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))
    
    main(numero_de_tiros, numero_de_intentos)

Una aclaración, el random.randint sí incluye el numero limite que le pongas, el que no lo incluye es el numpy.random.randint.

Se agrego numero de daos y se deja elegir el numero de la probablididad

import random

def tirar_dado(numero_de_tiros, numero_de_dados):
    secuencia_de_tiros = []
    
    for i in range(numero_de_tiros):
        tiro = random.choice([1,2,3,4,5,6]*numero_de_dados)
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_simulaciones, numero_de_dados, numero):
    tiros= []
    for i in range(numero_de_simulaciones):
        secuencia_de_tiros = tirar_dado(numero_de_tiros, numero_de_dados)
        tiros.append(secuencia_de_tiros)

    cant_numero = 0
    for tiro in tiros:
        if numero  in tiro:
            cant_numero += 1
     
    probabilidad_tiros_con_1 = cant_numero / numero_de_simulaciones
    print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_1}')

if __name__ == '__main__':
    numero_de_probabilidad = int(input('Que numero: '))
    numero_de_dados = int(input('Cuantos dados: '))
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_simulaciones = int(input("Numero de simulaciones: "))

    main(numero_de_tiros, numero_de_simulaciones, numero_de_dados, numero_de_probabilidad)

yo lo hice para ver la probabilidad de 12 en cada tiro.

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    tiros_otro_dado = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        
        secuencia_de_tiros_otro_dado=tirar_dado(numero_de_tiros)#variable en el caso de 2 dados para el 12
        tiros.append(secuencia_de_tiros)
        
        tiros_otro_dado.append(secuencia_de_tiros_otro_dado)#variable en el caso de 2 dados para el 12

    #tiros_con_1 = 0
    #for tiro in tiros:
    #    if 1 not in tiro:
    #        tiros_con_1 += 1 
    
    tiros_con_12=0
    for i in range(numero_de_intentos):
        for j in range(numero_de_tiros):
            #print(f'valor de primer dado = {tiros[i][j]}')
            #print(f'valor de segundo dado = {tiros_otro_dado[i][j]}')
            suma =tiros[i][j] + tiros_otro_dado[i][j]
            if suma==12:
                #print(f'la suma es {suma}')
                tiros_con_12+=1
            suma=0

    
   
    #probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos
    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de  obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')



if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantas tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos)

para sacar un 12, lanzando 2 dados 10 veces, analiticamente obtengo un 27% de probabilidad pero al correr la simulación 1.000.000 de veces, obtengo un 24,70. es una gran diferencia.

Les comparto mi código, pensado que lanza dos dados a la vez y calcula la probabilidad, de que la sumatoria de los números de como resultado 12.

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros_suma = []

    for _ in range(numero_de_tiros):
        tiro_1 = random.choice([1, 2, 3, 4, 5, 6])
        tiro_2 = random.choice([1, 2, 3, 4, 5, 6])
        tiro_suma = tiro_1 + tiro_2
        print(f'dado 1 salio {tiro_1} + dado 2 salio {tiro_2} = {tiro_suma}')
        secuencia_de_tiros_suma.append(tiro_suma)

    return secuencia_de_tiros_suma
    
def main(numero_de_tiros, numero_de_intentos):
    tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros_suma = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros_suma) 
        
    tiros_con_12 = 0

    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(tiros)
    print(f'Probabilidad de obtener por lo menos un 12 sumando dos dados en {numero_de_tiros} tiros= {probabilidad_tiros_con_12}')


if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros de los dos dados: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos)

Nunca pares de aprender

Cuantos tiros del dado: 10
Cuantas veces correra la simulación: 10000
Numero de dados a utilizar: 2
Probabilidad de obtener por lo menos un 12 en 10000 tiros = 0.2435

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        dado_1 = random.choice([1,2,3,4,5,6])
        dado_2 = random.choice([1,2,3,4,5,6])
        tiro = dado_1 + dado_2
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros


def main(numero_de_tiros,numero_de_intentos):
    tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    
    #Probabilidad de que en una secuencia de tiros obtengamos un "12"
    tiros_igual_a_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_igual_a_12 += 1
    
    probabilidad_tiros_igual_a_12 = tiros_igual_a_12 / numero_de_intentos
    print(f'probabilidad de NO obtener por lo menos un "12" en {numero_de_tiros} tiros = {probabilidad_tiros_igual_a_12}')


if __name__ == "__main__":
    numero_de_tiros = int(input("Cuantos tiros del dado?: "))
    numero_de_intentos = int(input("Cuantas veces correrá la simulación?: "))

    main(numero_de_tiros,numero_de_intentos)
import random


def throw_dice(number_shots: int) -> list:
    return [random.choice([1, 2, 3, 4, 5, 6]) for _ in range(number_shots)]


def main(number_shots: int, number_tries: int):
    shots = [throw_dice(number_shots) for _ in range(number_tries)]
    one = sum([1 for shot in shots if 1 in shot])
    probabilistic_one = one/number_tries
    print(f'Prob of one is {probabilistic_one} over {number_tries}')


if __name__ == '__main__':
    number_shots = int(input())
    number_tries = int(input())

    main(number_shots, number_tries)

Adjunto el código un poco modificado y una gráfica de la distribución de probabilidad normalizada comparada con el valor analítico de, por ejemplo, que salga el #12.

# -*- coding: utf-8 -*-
import random as rd
import matplotlib
import matplotlib.pyplot as plt


def roll_the_dice(tries):
    tries_result = []
    for _ in range(tries):
        dice1 = rd.randint(1, 6)
        dice2 = rd.randint(1, 6)
        final_result = dice1 + dice2
        tries_result.append(final_result)
    return tries_result


def prob(simulation_results, simulations):
    tries_for_number = 0
    probability_for_number = []
    for i in simulation_results:
        if 12 in i:
            tries_for_number += 1
        a = tries_for_number / simulations
        probability_for_number.append(a)
    return probability_for_number


def probability_plot(simulations, probability):
    simulation_array = list(range(simulations))
    fig, ax = plt.subplots()
    probability_plot, = ax.plot(simulation_array, probability)
    analytical, = ax.plot([0, len(simulation_array)], [0.027, 0.027], color='r')
    plt.ylim(0, 0.1)
    plt.xlim(0, len(simulation_array))
    ax.set(xlabel='Number of simulations', ylabel='Probability',
           title='Normalized Probability Distribution')
    ax.legend([analytical, probability_plot], ('Analytical', 'Simulated'), loc='upper right')
    ax.grid()
    plt.show()

def run(tries, simulations):
    simulation_results = []
    for i in range(simulations):
        simulation = roll_the_dice(tries)
        simulation_results.append(simulation)
    probability = prob(simulation_results, simulations)
    probability_plot(simulations, probability)
    return probability


if __name__ == '__main__':
    tries = int(input('Enter the number of tries: '))
    simulations = int(input('Enter the number of simulations: '))

    print(run(tries, simulations))

Excelente aproximación!

Aqui esta el codigo para calcular un doble 6

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    tiros_con_12 = 0

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        secuencia_de_tiros_2 = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
        if 6 in secuencia_de_tiros and 6 in secuencia_de_tiros_2:
            tiros_con_12 += 1```

Una forma sencilla de hacerlo sin modificar mucho el código original, tal vez les ayude a comprender mejor si están un poco perdidos.

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro_doble = random.choice([1, 2, 3, 4, 5, 6]) + random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro_doble)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro :
            tiros_con_12 += 1

    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')
   

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos)
    ```

Solo fue agregar otro dado, haciendo el mismo proceso que el primero, calcular la probabilidad individual y luego multiplicarla

def main(vecez_tiro_dados, numero_de_intentos):
    tiros_1 = []
    tiros_2 = []

    for _ in range(numero_de_intentos):
        secuencia_dado_1 = tirar_dado(vecez_tiro_dados)
        secuencia_dado_2 = tirar_dado(vecez_tiro_dados)

        tiros_1.append(secuencia_dado_1)
        tiros_2.append(secuencia_dado_2)

    tiros_con_1 = 0
    for tiro in tiros_1:
        if 6 in tiro:
            tiros_con_1 += 1
    probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos

    tiros_con_2 = 0
    for tiro in tiros_2:
        if 6 in tiro:
            tiros_con_2 += 1
    probabilidad_tiros_con_2 = tiros_con_2 / numero_de_intentos

    probabilidad_total = probabilidad_tiros_con_1 * probabilidad_tiros_con_2
    print(probabilidad_total)```

*Esta es mi propuesta del reto

import random


def tirar_dado(numero_de_tiros):
    secuencia_de_tiros=[]

    for _ in range(numero_de_tiros):
        dados=random.choice([1,2,3,4,5,6])
        #uso la misma variable solo que le sumo lo que corresponde del 2° dado
        #ya que tengola suma de los que corresponde a los 2 dados  lo almaceno
        dados+=random.choice([1,2,3,4,5,6])

        secuencia_de_tiros.append(dados)

    return secuencia_de_tiros

def main(numero_de_tiros,numero_de_intentos):
    tiros=[]
    for _ in range(numero_de_intentos):
        secuencia_de_tiros=tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    #claro que tambien hago los cambios corrreaondientes para que se evalue el 12
    tiros_con_12=0
    for tiro in tiros:
        if  12  in tiro: #if 1 not in tiro:
            tiros_con_12+=1

    probabilidad_de_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilida no de obtener un 12 en {numero_de_tiros} tiros = {probabilidad_de_tiros_con_12}')


if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros desea realizar: '))
    numero_de_intentos =int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros,numero_de_intentos)

Solo agregue otro dado al “tirar_dado” y los sume en el return, ya con eso funciono bien el codigo, me parecio una solucion bastante limpia, nose si esto tendra algun problema

Realización del Reto:

import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []
    
    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        tiro2 = random.choice([1, 2, 3, 4, 5, 6])
        tirar_2_dados = tiro + tiro2
        secuencia_de_tiros.append(tirar_2_dados)
        
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
        
    tiros_con_12 = 0
    for tiro in tiros:
        if 12  in tiro:
            tiros_con_12 += 1
            
    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado:'))
    numero_de_intentos = int(input('cuantas veces correra la simulacion: '))
    
    main(numero_de_tiros, numero_de_intentos)

la probabilidad de par 6 en 1 lanzamientos es de: 7.199999999999999 %

self.lados_del_dado = [1,2,3,4,5,6,6] #dado cargado

( ͡° ͜ʖ ͡°)

Hola! Mi código del reto es el siguiente:

import random

def tirar_dado(numero_de_tiros):
	secuencia_de_tiros = []

	for _ in range(numero_de_tiros):
		dado1 = random.choice([1,2,3,4,5,6])
		dado2 = random.choice([1,2,3,4,5,6])
		secuencia_de_tiros.append(dado1+dado2)

	return secuencia_de_tiros

def main( numero_de_tiros, numero_de_intentos):
	tiros = []
	for _ in range(numero_de_intentos):
		secuencia_de_tiros = tirar_dado(numero_de_tiros)
		tiros.append(secuencia_de_tiros)

	tiros_con_12 = 0

	for tiro in tiros:
		if 12 in tiro: #if 1 not in tiro:
			tiros_con_12 += 1

	probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
	print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')


if __name__== '__main__':
	numero_de_tiros = int(input('Cuantas tiros del dado: '))
	numero_de_intentos = int(input('Cuantas veces correra la simulación: '))

	main(numero_de_tiros, numero_de_intentos)

Como pueden ver en la función tirar_dado hay 2 variables llamadas dado las cuales sumo su resultado y lo guardo en el array.

Es básicamente lo mismo, pero con dos dados, al igual un solo lanzamiento sólo puede dar un resultado.

Interesante si debo guardar los resultados de cada dado por aparte y verificar cuál tiende más hacia un número (Eso no lo sabría hacer)

import random


def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        dado_1 = random.choice([1, 2, 3, 4, 5, 6])
        dado_2 = random.choice([1, 2, 3, 4, 5, 6])

        tiro  = (dado_1 + dado_2)

        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros


def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
    
    tiros_con_12 = 0
    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1

    probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener un 12 en {numero_de_tiros} tiros, es igual a {probabilidad_tiros_con_12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuántos tiros del dato: '))
    numero_de_intentos = int(input('Cuántas veces correrá la simulación: '))

    main(numero_de_tiros, numero_de_intentos)
import random

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range (numero_de_tiros):
        tiro = random.choice([1,2,3,4,5,6])
        tiro2 =  random.choice([1,2,3,4,5,6])
        tiro = tiro + tiro2
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def daddo(numero_de_tiros, numero_de_intentos):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    tiros_con_12 = 0

    for tiro in tiros:
        if 12 in tiro:
            tiros_con_12 += 1
    probabilidad_De_tiros_con12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener porlomenos un 1 en {numero_de_tiros} tiros = {probabilidad_De_tiros_con12}')


if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantas veces tiramos los dos dados?: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion?: '))
    daddo(numero_de_tiros, numero_de_intentos) ```
<import random

def tirada(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro_uno = random.choice([1, 2, 3, 4, 5, 6])
        tiro_dos = random.choice([1, 2, 3, 4, 5, 6])
        suma = tiro_uno + tiro_dos
        secuencia_de_tiros.append(suma)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_simulaciones):
    tiros = []
    
    for _ in range(numero_de_simulaciones):
        tiro = tirada(numero_de_tiros)
        tiros.append(tiro)

    tiros_con_uno = 0
    for t in tiros:
        if 12 in t:
            tiros_con_uno += 1
    
    probabilidad_tiros_con_1 = tiros_con_uno / numero_de_simulaciones
    print(f'La probabilidad de tiros con 1 es {probabilidad_tiros_con_1}')

if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros quieres?: '))
    numero_de_simulaciones = int(input('Cuantas veces deseas correr la simulacion?: '))
    main(numero_de_tiros, numero_de_simulaciones)
    
    
>

Reto: ¿Cual es la probabilidad de obtener 12 al lanzar dos dados justos en 10 lanzamientos? Sean X1 y X2 dos dados independientes entonces P(X1 +X2 = 12) = (1/6)*(1/6) = 1/36. Esto lo multiplicamos por 10 entonces (1/36) * 10 = 0.277777

Escribe el numero lanzamientos: 10
Escribe el numero de intentos: 100000
0.24616

Asi resolvi la probabilidad de sacar 12 con dos dados

`import random

def tirar_dado(numero_de_tiros):
secuencia_de_tiros = []

for _ in range(numero_de_tiros):
    tiro = random.choice([1, 2, 3, 4, 5, 6])
    secuencia_de_tiros.append(tiro)
return secuencia_de_tiros

def tirar_dos_dados(numero_de_tiros):
secuencia_de_tiros = []

for _ in range(numero_de_tiros):
    tiro1 = random.choice([1, 2, 3, 4, 5, 6])
    tiro2 = random.choice([1, 2, 3, 4, 5, 6])
    tiro = tiro1 + tiro2
    secuencia_de_tiros.append(tiro)
return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
tiros = []
tiros_dobles =[]

for _ in range (numero_de_intentos):
    secuencia_de_tiros = tirar_dado(numero_de_tiros)
    tiros.append(secuencia_de_tiros)
    secuencia_de_tiros_dos_dados = tirar_dos_dados(numero_de_tiros)
    tiros_dobles.append(secuencia_de_tiros_dos_dados)

tiros_con_1 = 0

for tiro in tiros:
    if 1 in tiro:
        tiros_con_1 += 1
    

probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos
print(f'Probabilidad de obtener por lo menos un 1 en {numero_de_tiros} tiros = {probabilidad_tiros_con_1} ')



tiros_con_12 = 0

for tiro in tiros_dobles:
    if 12 in tiro:
        tiros_con_12 += 1

probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12} ')

if name == ‘main’:
numero_de_tiros = int(input(‘Cuantas veces quieres tirar el dado por cada intento:’))
numero_de_intentos = int(input(‘Cuantos intentos se correran en la simulacion:’))

main(numero_de_tiros, numero_de_intentos)`

Hice una mini interfaz para hacer el código más flexible.

import random


def tirar_dado(numero_tiros, numero_dados):
    secuencia_de_tiros = []
    tiros = []
    for _ in range(numero_tiros):
        for _ in range(numero_dados):
            tiros.append(random.choice([1, 2, 3, 4, 5, 6]))

        tiro = sum(tiros)
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros


def interfaz():
    pase = False
    condicion_1 = False
    condicion_2 = False

    while(not pase):

        numero_tiros = int(input('¿Cuántos veces tiramos los dados?: '))
        numero_de_intentos = int(input('¿Cuántas veces repetimos el experimento?: '))
        numero_dados = int(input('Ingrese el número de dados: '))

        while(not condicion_1):
            numero_deseado = int(input('¿Qué numero desea comprobar?: '))

            if numero_deseado > numero_dados * 6 or numero_deseado < numero_dados * 1:
                print('Número fuera de los límites, ingrese datos nuevamente')
                break
            else:
                condicion_1 = True

        while(not condicion_2 and condicion_1):
            metodo = int(input(f'¿Desea saber la probabilidad de que el número {numero_deseado} salga a lo menos una vez, o que no salga en {numero_tiros} tiros? (Escoja 1(que salga) o 2(que no salga)): '))
            if metodo == 1 or metodo == 2:
                condicion_2 = True
                pase = True

            else:
                print('Método no válido, ingrese datos nuevamente')
                condicion_1 = False


    return numero_tiros, numero_de_intentos, numero_deseado, metodo, numero_dados


def main(numero_tiros, numero_de_intentos, numero_deseado, metodo, numero_dados):
    tiros = []
    for _ in range(numero_de_intentos):
        tiros.append(tirar_dado(numero_tiros, numero_dados))

    tiros_con_numero_deseado = 0
    if metodo == 1:
        for tiro in tiros:
            if numero_deseado in tiro:
                tiros_con_numero_deseado += 1
    elif metodo == 2:
        for tiro in tiros:
            if numero_deseado not in tiro:
                tiros_con_numero_deseado += 1

    probabilidad_tiros_con_numero_deseado = tiros_con_numero_deseado / numero_de_intentos
    print(f'Probabilidad de {"no obtener"  if metodo == 2 else "obtener por lo menos"} un {numero_deseado} en {numero_tiros} tiros = {probabilidad_tiros_con_numero_deseado}')


if __name__ == '__main__':
    numero_tiros, numero_de_intentos, numero_deseado, metodo, numero_dados = interfaz()
    main(numero_tiros, numero_de_intentos, numero_deseado, metodo, numero_dados)

import random

def tirar_dado(numero_de_tiros):
secuencia_de_tiros = []

for _ in range(numero_de_tiros):
	tiro1 = random.choice([1, 2, 3, 4, 5, 6])
	tiro2 = random.choice([1, 2, 3, 4, 5, 6])
	tiro = tiro1 + tiro2
	secuencia_de_tiros.append(tiro)

return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
tiros = []
for _ in range(numero_de_intentos):
secuencia_de_tiros = tirar_dado(numero_de_tiros)
tiros.append(secuencia_de_tiros)

tiros_con_12 = 0
for tiro in tiros:
	if 12  in tiro:
		tiros_con_12 += 1

probabilidad_tiros_con_12 = tiros_con_12/numero_de_intentos
print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')

if name == ‘main’:
numero_de_tiros = int(input('Cuantos tiros del dado: '))
numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

main(numero_de_tiros, numero_de_intentos)

Utilicé numpy para la simulación:

attempts = int(input('Número de intentos: '))
    dice_rolls = int(input('Número de lanzamientos: '))
    dice = [1, 2, 3, 4, 5, 6]
    number_dices = 2
    probability_sides = [1/6, 1/6, 1/6, 1/6, 1/6, 1/6]

    # Tirar dados.
    experiments_results = np.random.choice(
                            dice,
                            size = [attempts, dice_rolls, number_dices],
                            p = probability_sides
                        )

y calculé las siguientes probabilidades:

# Obtener al menos un 3 y un 6 en dos dados al lanzarlos cinco veces.
    total_events = 0
    for results in experiments_results.tolist():
        if (results.count([3, 6]) + results.count([6, 3])) > 0:
            total_events += 1

    probability = total_events / attempts
    print( 'La probabilidad de obtener al menos un 3 y un 6 en dos dados al ' \
          f'lanzarlos cinco veces es: {round(probability, 4)} ' \
          f'---> {round(probability * 100, 2)}%')

    # Obtener al menos dos números 5 al lanzar dos dados cinco veces.
    total_events = 0
    for results in experiments_results:
        if np.extract(results == 5, results).size > 1:
            total_events += 1

    probability = total_events / attempts
    print( 'La probabilidad de obtener al menos dos números 5 al lanzar ' \
          f'dos dados cinco veces: {round(probability, 4)} ' \
          f'---> {round(probability * 100, 2)}%')

obteniendo los siguientes resultados:

Al realizar el cálculo analítico, según yo, los resultados son correctos.

Hice una versión simplificada que te permite elegir la cantidad de lados del dado.

<import random

def num_one_is_found(throws: int, sides: int) -> bool:
    """Create a list of the numbers obtained by throwing a dice a number of times.

    Parameters:
        throws (int): The amount of times the dice will be thrown.
        sides (int): The number of sides of the dice.

    Returns:
        one_found (bool): A bool value that depends if num 1 is in numbers_obtained
    """

    dice = [i for i in range(1, sides+1)]
    numbers_obtained = [random.choice(dice) for throw in range(throws)]
    one_found = 1 in numbers_obtained
    return one_found

def get_a_num_prob(throws: int, n_simulations: int, sides:int=6) -> float:
    """Estimates the probability of getting a number in a dice roll.

    Parameters:
        throws (int): The amount of times the dice will be thrown.
        n_simulations (int): The number of times num_one_is_found will be called.
    
    Returns:
        prob (float): The number of times_one_was_found divided by n_simulations.
    """
    times_one_was_found = 0

    for _simulation in range(n_simulations):
        times_one_was_found += num_one_is_found(throws, sides)
    
    prob = times_one_was_found/n_simulations
    print(f'The probability of getting any "one" in {throws} throws is {prob}')
    return prob

sides = int(input('How many sides does the dice have: '))
throws = int(input('Times you will throw the dice: '))
n_simulations = int(input('Number of simulations: '))

print(get_a_num_prob(throws, n_simulations, sides=sides))>

RETO

import random

def tirar_dado(numero_de_tiros,eleccion):
    secuencia_de_tiros = []
    for _ in range (numero_de_tiros):
        tiro1 = random.choice([1, 2, 3, 4, 5, 6])
        tiro2 = random.choice([1, 2, 3, 4, 5, 6])
        if eleccion==1:
            tiro=tiro1
        elif eleccion==2:
            tiro=tiro1+tiro2
        secuencia_de_tiros.append(tiro)       
    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos,eleccion):
    tiros = []
    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros,eleccion)
        tiros.append(secuencia_de_tiros)
    
    if eleccion ==1:
        tiros_con_1 = 0
        for tiro in tiros:
            if 1  in tiro:
                tiros_con_1 += 1
        probabilidad_tiros_con_1 = tiros_con_1 / numero_de_intentos
        print(f'Probabilidad de obtener por lo menos un 1 en {numero_de_tiros} tiros = {probabilidad_tiros_con_1}')

    elif eleccion ==2:
            tiros_con_12 = 0
            for tiro in tiros:
                if 12 in tiro:
                    tiros_con_12+=1
            probabilidad_tiros_con_12 = tiros_con_12 / numero_de_intentos
            print(f'Probabilidad de obtener por lo menos un 12 en {numero_de_tiros} tiros = {probabilidad_tiros_con_12}')

if __name__ == '__main__':
    print(f'Cálculo de no obtener por lo menos un 1 o cualquier numero en una secuencia de tiros de un solo dado escoja 1')
    print(f'Cálculo de obtener 12 en una secuencia de tiros de dos dados escoja 2')
    eleccion=int(input('Opcion elegida: '))

    numero_de_tiros = int(input('Cuantas tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos,eleccion)

Mi reto:

import random

#probabilidad de obtener un 12 al lanzar dos dados
def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)

    return secuencia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros1 = []
    tiros2 = []
    for _ in range(numero_de_intentos):
        #secuencia de tiros según número de dados
        secuencia_de_tiros1 = tirar_dado(numero_de_tiros)
        secuencia_de_tiros2 = tirar_dado(numero_de_tiros)
        tiros1.append(secuencia_de_tiros1)
        tiros2.append(secuencia_de_tiros2)

    
    #comparo si sale un 12 al lanzar los dados
    i = 0
    tiros_con_6 = 0
    for tiro in tiros1:
        if (6 in tiro and 6 in tiros2[i]):
            tiros_con_6 += 1
        i+=1
        

    probabilidad_tiros_con_6 = tiros_con_6 / numero_de_intentos
    print(f'Probabilidad de obtener 12 al lanzar 2 dados en {numero_de_tiros} tiros = {probabilidad_tiros_con_6}')
 

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantas tiros de los dados: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos)```

Mi Reto:

import random

def tirar_dado(numero_de_tiros):
    secuenccia_de_tiros = []

    for _ in range(numero_de_tiros):
        tiro_1 = random.choice([1, 2, 3, 4, 5, 6])
        tiro_2 = random.choice([1, 2, 3, 4, 5, 6])
        secuenccia_de_tiros.append(tiro_1 + tiro_2)

    return secuenccia_de_tiros

def main(numero_de_tiros, numero_de_intentos):
    tiros = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)

    probabilidad = {}
    for i in range(2, 13):
        contador = 0
        for tiro in tiros:
            if i in tiro:
                contador += 1
        probabilidad[i] = contador / numero_de_intentos
        contador = 0
    probabilidad_total = 0 
    for numero, probabilidad in probabilidad.items():
        probabilidad_total += probabilidad
        print(f'Probabilidad de obtner por lo menos un {numero} en {numero_de_tiros} tiros = {probabilidad}')
    
    print(f'Probabilidad total = {probabilidad_total}')
    

if __name__ == "__main__":
    numero_de_tiros = int(input('Cuentos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulación: '))
    
    main(numero_de_tiros, numero_de_intentos)```
import random


def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []
    for _ in range(numero_de_tiros):
        tiro = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(tiro)
    return secuencia_de_tiros
    

def main(numero_de_tiros, numero_de_intentos): 
    tiros = []
    tiros_2 = []

    for _ in range(numero_de_intentos): 
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        secuencia_de_tiros_2 = tirar_dado(numero_de_tiros)
        print(secuencia_de_tiros, secuencia_de_tiros_2)
        tiros.append(secuencia_de_tiros)
        tiros_2.append(secuencia_de_tiros_2)

    tiros_con_12 = 0 
    primer_dado = 0
    segundo_dado = 0 
    for _ in tiros: 
        print(f'h{tiros[primer_dado]}, {tiros_2[segundo_dado]}')
        if 6 in tiros[primer_dado] and 6 in tiros_2[segundo_dado]: 
            tiros_con_12 += 1
        primer_dado +=1 
        segundo_dado += 1 
            

    probabilidad_de_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de de obtener un 12 con 2 dados en {numero_de_tiros} tiros = {probabilidad_de_tiros_con_12}')

if __name__ == "__main__":
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulacion: '))

    main(numero_de_tiros, numero_de_intentos)```
import random 

def tirar_dado(numero_de_tiros):
    secuencia_de_tiros = []
    for _ in range(numero_de_tiros):
        dado = random.choice([1, 2, 3, 4, 5, 6])
        secuencia_de_tiros.append(dado)

    return secuencia_de_tiros


def main(numero_de_tiros, numero_de_intentos):
    tiros = []
    tiros_2 = []

    for _ in range(numero_de_intentos):
        secuencia_de_tiros = tirar_dado(numero_de_tiros)
        secuencia_de_tiros_2 = tirar_dado(numero_de_tiros)
        tiros.append(secuencia_de_tiros)
        tiros_2.append(secuencia_de_tiros_2)
    
    tiros_con_12 = 0

    for index in range(0, len(tiros)):
        if 6 in tiros[index] and 6 in tiros_2[index]:
            tiros_con_12 += 1
    
    probabilidad_de_tiros_con_12 = tiros_con_12 / numero_de_intentos
    print(f'Probabilidad de obtener por lo menos un 12 en { numero_de_tiros } lanzamientos = {probabilidad_de_tiros_con_12}')

if __name__ == '__main__':
    numero_de_tiros = int(input('Cuantos tiros del dado: '))
    numero_de_intentos = int(input('Cuantas veces correra la simulación: '))

    main(numero_de_tiros, numero_de_intentos)