nopat_ja_kolikot.py

# Write some code and hack the planet!
# Author: nucular moo

############################################################
#               FyLT_nopat_ja_kolikot.py                   #
############################################################
# Kurssi: Fysiikka Luonnontieteilijoille                   #
# Ajankohta: Kesa 2019                                     #
# Tehtava: Tutkielma 4                                     #
#                                                          #
# Ohjelma keskittyy todennakoisyyksien selvittamiseen      #
# ennalta kuvatuissa koetilanteissa.                       #
#                                                          #
# Ohjelma simuloi noppien ja kolikoiden heittoja seka      #
# tallentaa heittojen tulokset Pandas DataFrame-tyyypisiin #
# tietorakenteisiin                                        #
############################################################

import random
import pandas as pd
import numpy as np

####################
# kolikon_heitto() #
############################################################
# random.randint(0,1) arpoo muuttujan p arvoksi 0 tai 1    #
#                                                          #
# funktio kolikon_heitto() tulkitsee muuttujan p arvon     #
# siten, etta 0 = Kruuna, 1 = Klaava                       #
#                                                          #
# funktio kolikon_heitto() ilmoittaa ensin heiton          #
# tuloksen, jonka jalkeen se palauttaa muuttujan p arvon   #
############################################################

def kolikon_heitto():

    p = random.randint(0,1)
    kolikko(p)

    return p

def kolikko(p):

    id = {0:"kruuna", 1:"klaava"}
    tulos = "Heitit kolikkoa! Tuloksesi on " + id[p] + "!"
    print(tulos)

def kolikon_arvo(n):
    if n is 0:
        return "Kruuna"
    elif n is 1:
        return "Klaava"


##################
# nopan_heitto() #
############################################################
# random.randint(1,6) arpoo muuttujan n arvoksi jotain     #
# valilta 1-6                                              #
#                                                          #
# funktio nopan_heitto() tulkitsee muuttujan n arvon niin, #
# etta jokainen arvo vastaa nopan saman arvoista           #
# silmalukua                                               #
#                                                          #
# funktio nopan_heitto() ilmoittaa ensin heiton tuloksen,  #
# jonka jalkeen se palauttaa muuttujan n arvon             #
############################################################

def nopan_heitto():

    n = random.randint(1,6)
    noppa(n)

    return n

def noppa(n):

    tulos = "Heitit noppaa! Tuloksesi on " + nopan_silmaluku(n) + "!"
    print(tulos)

def nopan_silmaluku(n):

    lukutaulu = {1:"Yksi", 2:"Kaksi", 3:"Kolme", 4:"Nelja", 5:"Viisi", 6:"Kuusi"}

    return lukutaulu[n]


###############
# heita(n, s) #
############################################################
# funktio heita() heittaa osallistujalle nimelta n         #
# esinetta tyyppia s jotta voisimme saada mielenkiintoisia #
# tuloksia seka oppia ymmartamaan todennakoisyyksia        #
# aiempaa paremmin
#                                                          #
# osallistujat voivat kayttaa samaa noppaa ja kolikkoa     #
# supernopeasti perakkain, silla meidan ei tarvitse ottaa  #
# ilmanvastusta lainkaan huomioon koodia suorittaessamme!  #
############################################################

def heita(name, switch):

    print(name + " heittaa " + switch + "a:")
    if switch is "noppa":
        return nopan_heitto()
    elif switch is "kolikko":
        return kolikon_heitto()


############################
# ensimmainen_koe(o, s, k) #
############################################################
# funktio ensimmainen_koe() toistaa ohjeistuksen           #
# sekvenssin: "Jokainen (o in osallistujat) heittaa        #
# kolikkoa (k=10) kertaa, ja kirjaa tulokset ylos."        #
#                                                          #
# funktio palauttaa Pandas DataFrame-objektin jolla header #
# muodossa:                                                #
#                                                          #
# |-----------------------------------------------|        #
# | jasen_1 | jasen_2 | jasen_3 | ..... | jasen_n |        #
# |---------|---------|---------|-------|---------|        #
# | tulos_1 | tulos_1 | tulos_1 | ..... | tulos_1 |        #
# | tulos_2 | tulos_2 | tulos_2 | ..... | tulos_2 |        #
# | jne.._3 | jne.._3 | jne.._3 | ..... | jne.._3 |        #
# |-----------------------------------------------|        #
#                                                          #
# Dataframen arvot tulkitaan seuraavasti:                  #
#                                                          #
# | Kruuna = 0 | Klaava = 1 |                              #
#                                                          #
############################################################

def ensimmainen_koe(osallistujat, switch, k):
    ind = generoi_indeksit(k)
    df = pd.DataFrame(columns=osallistujat)
    for i in range(k):
        print("Kierros " + str(i+1))
        print("<><><><><>")
        result = kierros(osallistujat, switch)
        df.loc[len(df)] = result
        print("")

    df.index = ind

    return df

def kierros(osallistujat, switch):
    result = []
    for osallistuja in osallistujat:
        tulos = heita(osallistuja, switch)
        result.append(kolikon_arvo(int(tulos)))

    return result

def generoi_indeksit(k):

    heitot = []
    for i in range(k):
        heitot.append("Kierros " + str(i+1))

    return heitot


############################
# toinen_koe(o, s, k, seq) #
############################################################
#                                                          #
# funktio toinen_koe() toistaa ohjeistuksen sekvenssin:    #
# "Jokainen (o in osallistujat) heittaa kolmea (seq=3      #
# kolikkoa yhta aikaa (k=10) kertaa, ja kirjaa tulokset    #
# ylos."                                                   #
#                                                          #
# funktio palauttaa Pandas DataFrame-objektin muodossa:    #                                            #
#                                                          #
# |-----------------------------------------------|        #
# | jasen_1 | tulos_1 | tulos_2 | ..... | tulos_n |        #
# | jasen_2 | tulos_1 | tulos_2 | ..... | tulos_n |        #
# | ....... | ....... | ....... | ..... | ....... |        #
# | jasen_n | tulos_1 | tulos_2 | ..... | tulos_n |        #
# | jasen_1 | jne.._1 | tulos_2 | ..... | tulos_n |        #
# | ....... | ....... | ....... | ..... | ....... |        #
# |-----------------------------------------------|        #
#                                                          #
# Dataframen arvot tulkitaan seuraavasti:                  #
#                                                          #
# | Kruuna = 0 | Klaava = 1 |                              #
#                                                          #
############################################################

def toinen_koe(osallistujat, switch, k, seq):

    df = pd.DataFrame(columns=generoi_kolumnit(seq, switch))

    for i in range(k):
        kierros = "Kierros " + str(i+1)
        kf = pd.DataFrame(index=[kierros])
        print(kierros)
        print("<><><><><>")
        df = pd.concat([df, kf], sort='True')
        result = t_k_kierros(osallistujat, switch, seq)
        result.index = osallistujat
        print("")
        print("<><><><><><><><><><><><><><><><><><>")
        print(result)
        print("<><><><><><><><><><><><><><><><><><>")

        df = pd.concat([df, result], axis=0)
        print("")

    return df

def t_k_kierros(osallistujat, switch, seq):

    result = pd.DataFrame(columns=generoi_kolumnit(seq, switch))

    for osallistuja in osallistujat:
        kierroksen_tulos = (t_k_subkierros(osallistuja, switch, seq))
        print("")
        df = pd.DataFrame([kierroksen_tulos], columns=generoi_kolumnit(seq, switch))
        result = pd.concat([result, df], axis=0, sort='True')

    return result

def t_k_subkierros(osallistuja, switch, seq):
    result = []
    for i in range(seq):
        tulos = heita(osallistuja, switch)
        if switch is "kolikko":
            result.append(kolikon_arvo(tulos))
        elif switch is "noppa":
            result.append(nopan_silmaluku(tulos))

    return result

def generoi_kolumnit(seq, switch):
    heitot = []
    if switch is "kolikko":
        target = "Heitto "
    elif switch is "noppa":
        target = "Noppa "
    for i in range(seq):
        heitot.append(target + str(i+1))

    return heitot

##########################
# kolmas_koe(o, s, k, n) #
############################################################
#                                                          #
# funktio kolmas_koe() toistaa ohjeistuksen sekvenssin:    #
# "Jokainen (o in osallistujat) heittaa kahta (n)          #
# noppaa yhta aikaa (k=20) kertaa, ja kirjaa tulokset      #
# ylos."                                                   #
#                                                          #
# funktio palauttaa Pandas DataFrame-objektin muodossa:    #                                                #
#                                                          #
# |-----------------------------------------------|        #
# | jasen_1 | tulos_1 | tulos_2 | ..... | tulos_n |        #
# | jasen_2 | tulos_1 | tulos_2 |-------| tulos_n |        #
# | ....... | ....... | ....... | ..... | ....... |        #
# | jasen_n | tulos_1 | tulos_2 | ..... | tulos_n |        #
# | jasen_1 | jne.._1 | tulos_2 | ..... | tulos_n |        #
# | ....... | ....... | ....... | ..... | ....... |        #
# |-----------------------------------------------|        #
#                                                          #
# Dataframen arvot tulkitaan seuraavasti:                  #
#                                                          #
# | Yksi = 1 | Kaksi = 2 | ..... | Kuusi = 6 |             #
#                                                          #
############################################################

def kolmas_koe(osallistujat, switch, k, n):

    df = pd.DataFrame(columns=generoi_kolumnit(n, switch))
    for i in range(k):
        kierros = "Kierros " + str(i+1)
        kf = pd.DataFrame(index=[kierros])
        print(kierros)
        print("<><><><><>")
        df = pd.concat([df, kf], sort='True')
        result = t_k_kierros(osallistujat, switch, n)
        result.index = osallistujat
        print("")
        print("<><><><><><><><><><><><><><><><><><>")
        print(result)
        print("<><><><><><><><><><><><><><><><><><>")

        df = pd.concat([df, result], axis=0)
        print("")

    return df

def program_loop():
        print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
        print("<>                       Welcome!                             <>")
        print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")

        while(1):
            welcome()
            menu()

def welcome():

    print("")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("Tervetuloa pelaamaan pelia: Ryhma 1 heittaa kolikkoa ja noppaa!!")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("Pelissa simuloidaan nopan tai kolikon heittoa koetilanteesta")
    print("riippuen!")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")

def goodbye():

    print("")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("<>                       Goodbye!                             <>")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    exit()

def halp():

    print("")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("<>            Olet pyytanyt apua! Kuinka rohkeaa!             <>")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("")
    print("Koetilanne 1:")
    print("<><><><><><><>")
    print("Jokainen ryhman jasen heittaa yhta kolikkoa 10 kertaa ja kirjaa")
    print("tulokset ylos.")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("Koetilanne 2:")
    print("<><><><><><><>")
    print("Heittakaa kolmea kolikkoa yhta aikaa esim. 10 kertaa ja")
    print("kirjatkaa kuinka monta kruunua ja klaavaa kullakin kerralla")
    print("tulee.")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("Koetilanne 3:")
    print("<><><><><><><>")
    print("Heittakaa kahta noppaa yhta aikaa, ja kirjatkaa niiden")
    print("silmalukujen summa esim 20 kertaa.")
    print("")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("<>           Taman enempaa apua ei ole saatavilla :(          <>")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    print("")

def menu():

    print("")
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")
    command = raw_input('<> Valitse koetilanne (1|2|3) tai (Q)uit/(H)elp): ')
    print("<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>")

    quit = ('Q, q')
    help = ('H', 'h')

    if command is "1":

        keino, osallistujat = muuttujat("k")
        heittojen_lukumaara = 10
        tulos_1 = ensimmainen_koe(osallistujat, keino, heittojen_lukumaara)
        print(tulos_1)

    elif command is "2":

        keino, osallistujat = muuttujat("k")
        heittojen_lukumaara = 10
        hpk = 3
        tulos_2 = toinen_koe(osallistujat, keino, heittojen_lukumaara, hpk)
        print(tulos_2)

    elif command is "3":

        keino, osallistujat = muuttujat("n")
        heittojen_lukumaara = 20
        npk = 2
        tulos_3 = kolmas_koe(osallistujat, keino, heittojen_lukumaara, npk)
        print(tulos_3)


    elif command in quit:
        goodbye()

    elif command in help:
        halp()

def muuttujat(m):
    osallistujat = ["Erika", "Juuso", "Mikael"]

    if m is "n":
        return "noppa", osallistujat
    elif m is "k":
        return "kolikko", osallistujat

def main():

    pd.set_option('display.max_rows', 1000)

    program_loop()

if __name__ == "__main__":
    main()