aminozuur.py

#vraag 17 in de opdracht is fout
#Specifiek = eiwit dat voldoet aan een bepaalde eigenschap
#http://pypi.python.org/pypi/autopep8/

import random

#In deze matrix staat alle relevante data die gebruikt wordt om de vragen mee te maken
#Elke rij is een aminozuur en elke kolom is een type eigenschap
#0 = soort_aminozuur
#1 = 3 lettercode
#2 = 1 lettercode,
#3 = hydrofobiciteit
#4 = grootte
#5 = lading
#6 = preferentie
Aminozuur_matrix = [

    ["Alanine", "Ala", "A", "Hydrofoob", "Klein", "0", "H"],
    ["Arginine", "Arg", "R", "Hydrofiel", "Groot", "+", "N"],
    ["Asparagine", "Asn", "N", "Hydrofiel", "Middel", "0", "T"],
    ["Asparaginezuur", "Asp", "D", "Hydrofiel", "Middel", "-", "HT"],
    ["Cysteine", "Cys", "C", "Hydrofoob", "klein/middel", "0", "ST"],
    ["Fenylalanine", "Phe", "F", "Hydrofoob", "Groot", "0", "S"],
    ["Glutamine", "Gln", "Q", "Hydrofiel", "Groot", "0", "N"],
    ["Glutaminezuur", "Glu", "E", "Hydrofiel", "Groot", "-", "HS"],
    ["Glycine", "Gly", "G", "Tussenin", "Klein", "0", "T"],
    ["Histidine", "His", "H", "Hydrofiel", "Groot", "0", "N"],
    ["Isoleucine", "Ile", "I", "Hydrofoob", "Middel", "0", "S"],
    ["Leucine", "Leu", "L", "Hydrofoob", "Middel", "0", "HS"],
    ["Lysine", "Lys", "K", "Hydrofiel", "Groot", "+", "HT"],
    ["Methionine", "Met", "M", "Hydrofoob", "Groot", "0", "H"],
    ["Proline", "Pro", "P", "Hydrofoob", "Klein", "0", "T"],
    ["Serine", "Ser", "S", "Tussenin", "Klein", "0", "T"],
    ["Threonine", "Thr", "T", "Tussenin", "Klein", "0", "S"],
    ["Tryptofaan", "Trp", "W", "Hydrofoob", "Groot", "0", "S"],
    ["Tyrosine", "Tyr", "Y", "Hydrofoob", "Groot", "0", "S"],
    ["Valine", "Val", "V", "Hydrofoob", "Klein", "0", "S"]

]

def zoek_specifieke_aminozuren(eigenschap, voorwaarde):
    """
    Zoek alle eiwitten die de opgegeven eigenschap /wel/ bevatten
    """

    specifieke_aminozuren = []
    for aminozuur in Aminozuur_matrix:
        #'in' ipv '==' zodat gecombineerde voorwaarden ook als True uit de test komen:
        #if S == HS = False
        #if S in HS = True
        if voorwaarde in aminozuur[eigenschap]:
            specifieke_aminozuren.append(aminozuur)

    return specifieke_aminozuren


def zoek_specifieke_aminozuren_inv(eigenschap, voorwaarde):
    """
    Zoek alle eiwitten die de opgegeven eigenschap /niet/ bevatten
    """

    specifieke_aminozuren = []
    for aminozuur in Aminozuur_matrix:
        #'not in' ipv '!=' zodat gecombineerde voorwaarden ook als False uit de test komen:
        #if S != HS = True
        #if S not in in HS = False
        if voorwaarde not in aminozuur[eigenschap]:
            specifieke_aminozuren.append(aminozuur)

    return specifieke_aminozuren


def init_vraag():
    """
    Deze functie doet niets anders dan een procedure die vaak herhaald wordt in het script uitvoeren
    """

    aminozuur = kies_random_aminozuur()

    #De 3 noteringstypen mogen gebruikt worden in de vraag
    noteringstype = random.randint(0, 2)

    return aminozuur, noteringstype


def kies_random_aminozuur():
    """
    Kiest random een eiwit (rij) uit de Aminozuurmatrix
    """

    return random.choice(Aminozuur_matrix)


def creeer_specifieke_vraag(eigenschap, voorwaarde, noteringstype, vraag):
    """
    Creer een list en vul deze met het juiste antwoord en twee andere mogelijkheden die niet
    aan dezelfde voorwaarde voldoen als de voorwaarde van het juiste antwoord.
    """

    mogelijkheden = []

    #Kies het juiste antwoord, deze moet minimaal voorkomen in de mogelijkheden
    random_specifieke_aminozuur = random.choice(zoek_specifieke_aminozuren(eigenschap, voorwaarde))[
                                  noteringstype]
    mogelijkheden.append(random_specifieke_aminozuur)

    #Voeg random een tweede mogelijkheid toe met dezelfde soort eigenschap uit de matrix.
    #De andere mogelijkheden mogen niet aan dezelfde voorwaarde voldoen als die van het juiste antwoord! -> _inv
    tweede_keuze = random.choice(zoek_specifieke_aminozuren_inv(eigenschap, voorwaarde))[noteringstype]
    #Indien de gekozen tweede keuze al in de lijst met mogelijke keuzes voorkomt, kies een nieuwe!
    while tweede_keuze in mogelijkheden:
        tweede_keuze = random.choice(zoek_specifieke_aminozuren_inv(eigenschap, voorwaarde))[noteringstype]
    mogelijkheden.append(tweede_keuze)

    #Hetzelfde geldt voor de derde keuze
    derde_keuze = random.choice(zoek_specifieke_aminozuren_inv(eigenschap, voorwaarde))[noteringstype]
    while derde_keuze in mogelijkheden:
        derde_keuze = random.choice(zoek_specifieke_aminozuren_inv(eigenschap, voorwaarde))[noteringstype]
    mogelijkheden.append(derde_keuze)

    #Shuffle de vragen, anders is A altijd het juiste antwoord
    random.shuffle(mogelijkheden)

    antwoord = zoek_juiste_antwoord(mogelijkheden, random_specifieke_aminozuur)

    a = mogelijkheden[0]
    b = mogelijkheden[1]
    c = mogelijkheden[2]

    abc = ("A: %s\tB: %s\tC: %s" % (a, b, c))

    return vraag, abc, antwoord


def creeer_aspecifieke_vraag(aminozuur, eigenschap, vraag):
    mogelijkheden = []

    #Kies het juiste antwoord, deze moet minimaal voorkomen in de mogelijkheden
    juiste_keuze = aminozuur[eigenschap]

    mogelijkheden.append(juiste_keuze)

    #Kies random en voeg een tweede mogelijkheid toe aan de mogelijkheden
    tweede_keuze = kies_random_aminozuur()[eigenschap]
    #Indien de zojuist gekozen tweede keuze al in de lijst met mogelijke keuzes voorkomt, kies een nieuwe!
    while tweede_keuze in mogelijkheden:
        tweede_keuze = kies_random_aminozuur()[eigenschap]
    mogelijkheden.append(tweede_keuze)

    #Hetzelfde geldt voor de derde keuze
    derde_keuze = kies_random_aminozuur()[eigenschap]
    while derde_keuze in mogelijkheden:
        derde_keuze = kies_random_aminozuur()[eigenschap]
    mogelijkheden.append(derde_keuze)

    #Shuffle de vragen, anders is A altijd het juiste antwoord
    random.shuffle(mogelijkheden)

    antwoord = zoek_juiste_antwoord(mogelijkheden, juiste_keuze)

    a = mogelijkheden[0]
    b = mogelijkheden[1]
    c = mogelijkheden[2]

    abc = ("A: %s\tB: %s\tC: %s" % (a, b, c))

    return vraag, abc, antwoord


def zoek_juiste_antwoord(mogelijkheden, juiste_keuze):
    """
    Een beetje een vieze oplossing maar nu eenmaal nodig sinds de mogelijkheden random geshuffeld worden
    """
    if mogelijkheden[0] == juiste_keuze:
        antwoord = "A"
    elif mogelijkheden[1] == juiste_keuze:
        antwoord = "B"
    else:
        antwoord = "C"

    return antwoord


def namen_vraag():
    aminozuur, noteringstype_vraag = init_vraag()

    if noteringstype_vraag == 0:
        #Deze vraag kan uitsluitend met de volledige naam en 3-lettercode noteringstypen gevraagd worden
        noteringstype_vraag = random.choice([0, 1])
        eigenschap_vraag = 2
        vraag = ("Wat is de 1-lettercode van aminozuur %s?" % aminozuur[noteringstype_vraag])
    elif noteringstype_vraag == 1:
        #Deze vraag kan uitsluitend met de volledige naam en 1-lettercode noteringstypen gevraagd worden
        noteringstype_vraag = random.choice([0, 2])
        eigenschap_vraag = 1
        vraag = ("Wat is de 3-lettercode van aminozuur %s?" % aminozuur[noteringstype_vraag])
    else:
        #Deze vraag kan uitsluitend met de 1-letter -en 3-lettercode noteringstypen gevraagd worden
        noteringstype_vraag = random.choice([1, 2])
        eigenschap_vraag = 0
        vraag = ("Wat is de volledige naam van aminozuur %s?" % aminozuur[noteringstype_vraag])

    return creeer_aspecifieke_vraag(aminozuur, eigenschap_vraag, vraag)


def hydrofobiciteit_vraag(specifiek):
    aminozuur, noteringstype = init_vraag()

    if specifiek:
        vraag = "Wat is de hydrofobiciteit van aminozuur %s?" % aminozuur[noteringstype]
        abc = "A: %hydrofoob\tB: tussenin\tC: hydrofiel"

        juiste_antwoord = aminozuur[5]
        if juiste_antwoord == "hydrofoob":
            return vraag, abc, "A"
        elif juiste_antwoord == "tussenin":
            return vraag, abc, "B"
        else:
            return vraag, abc, "C"

    else:
        hydrofobiciteit = random.choice(["Hydrofiel", "Tussenin", "Hydrofoob"])
        if hydrofobiciteit == "Tussenin":
            vraag = "Welk aminozuur heeft een lading welke tussen hydrofoob en hydrofiel in zit? (tussenin)"
        else:
            vraag = ("Welk aminozuur is %s?" % hydrofobiciteit)

        return creeer_specifieke_vraag(3, hydrofobiciteit, noteringstype, vraag)


def grootte_vraag(specifiek):
    aminozuur, noteringstype = init_vraag()

    if specifiek:
        #Stel 1 op de 4 keer een klein/middel vraag
        if random.randint(0, 3) == 0:
            vraag = "Wat is de grootte van aminozuur %s?" % aminozuur[noteringstype]
            abc = "A: klein\tB: middel\tC: groot"

            juiste_antwoord = aminozuur[4]
            if juiste_antwoord == "+":
                return vraag, abc, "A"
            elif juiste_antwoord == "0":
                return vraag, abc, "B"
            else:
                return vraag, abc, "C"

        else:
            vraag = "Welk aminozuur zit tussen klein en middel in?"

            #Hoewel dit altijd Cysteine is, toch maar dynamisch geprogrammeerd zodat de matrix altijd nog aangepast kan
            #worden.
            return creeer_specifieke_vraag(4, "klein/middel", noteringstype, vraag)

    else:
        #Kies random of er gevraagd wordt of het aminozuur klein, middelgroot of groot is.
        grootte_gevraagd = random.choice(["Klein", "Middel", "Groot"])
        if grootte_gevraagd == "Klein":
            vraag = "Welk aminozuur is klein?"
        elif grootte_gevraagd == "Middel":
            vraag = "Welk aminozuur is middelgroot?"
        else:
            vraag = "Welk aminozuur is groot?"

        return creeer_specifieke_vraag(4, grootte_gevraagd, noteringstype, vraag)


def lading_vraag(specifiek):
    aminozuur, noteringstype = init_vraag()

    if specifiek:
        vraag = "Wat is de lading van %s?" % aminozuur[noteringstype]
        abc = "A: +\tB: 0\tC: -"

        juiste_antwoord = aminozuur[5]
        if juiste_antwoord == "+":
            return vraag, abc, "A"
        elif juiste_antwoord == "0":
            return vraag, abc, "B"
        else:
            return vraag, abc, "C"

    else:
        lading_gevraagd = random.choice(["+", "0", "-"])
        if lading_gevraagd == "+":
            vraag = "Welk aminozuur is positief geladen bij pH7,4?"
        elif lading_gevraagd == "0":
            vraag = "Welk aminozuur is neutraal geladen bij pH7,4?"
        else:
            vraag = "Welk aminozuur is positief geladen bij pH7,4?"

        return creeer_specifieke_vraag(5, lading_gevraagd, noteringstype, vraag)


def preferentie_vraag(specifiek):
    aminozuur, noteringstype = init_vraag()

    if specifiek:
        vraag = "Wat is de 3D preferentie van aminozuur %s?" % aminozuur[noteringstype]
        return creeer_aspecifieke_vraag(aminozuur, 6, vraag)

    else:
        #1 van de 4 keer wordt de "Geen preferentie" vraag gesteld
        if random.randint(0, 3) == 0:
            vraag = "Welk aminozuur heeft geen preferentie in 3D?"
            return creeer_specifieke_vraag(6, "N", noteringstype, vraag)

        else:
            preferenties = ["helix", "strand", "turn"]
            preferentie = random.choice(preferenties)

            vraag = "Welk aminozuur prefereert in 3D een %s?" % preferentie

            #preferentie_vraag[0].upper() = eerste letter van preferentie als hoofdletter
            return creeer_specifieke_vraag(6, preferentie[0].upper(), noteringstype, vraag)


def print_vraag(vraag):
    print(vraag[0])
    print(vraag[1])
    print("\n")


def main():
    printen = True
    opslaan = True

    #    print("Hoe wilt u de gegenereerde vragen terug krijgen?")
    #    print("\n")
    #    print("1. Print vragen op het scherm.")
    #    print("2. Sla de bestanden op in een bestand.")
    #    gebruiker = input("--> ")
    #
    #    if gebruiker == "2":
    #        opslaan = True
    #
    #    print("\n")


    #6/23 namen
    #4/23 hydrofobiciteit
    #3/23 lading
    #5/23 Grootte
    #5/23 3D
    aantal_vragen = input("Hoeveel vragen moeten er gemaakt worden? [minimaal 5 of meer] ")
    aantal_vragen = int(aantal_vragen) - 1

    gecreerde_vragen = []

    for n in range(int((6 / 23) * aantal_vragen)):
        vraag = namen_vraag()
        gecreerde_vragen.append(vraag)

    for g in range(int((5 / 23) * aantal_vragen)):
        rand = random.randint(0, 1)
        vraag = grootte_vraag(rand == 0)
        gecreerde_vragen.append(vraag)

    for l in range(int((3 / 23) * aantal_vragen)):
        rand = random.randint(0, 1)
        vraag = lading_vraag(rand == 0)
        gecreerde_vragen.append(vraag)

    for p in range(int((5 / 23) * aantal_vragen)):
        rand = random.randint(0, 1)
        vraag = preferentie_vraag(rand == 0)
        gecreerde_vragen.append(vraag)

    antwoorden_bestand = open("aminozuurtoets_ant_" + str(len(gecreerde_vragen)) + "_", "w")
    if opslaan:
        vragen_bestand = open("aminozuurtoets_vr_" + str(len(gecreerde_vragen)), "w")

    for vraag_nummer, vraag in enumerate(gecreerde_vragen):
        antwoorden_bestand.write(str(vraag_nummer + 1) + "\t" + vraag[2])
        antwoorden_bestand.write("\n")

        if opslaan:
            vragen_bestand.write("Vraag " + str(vraag_nummer + 1) + ": " + vraag[0])
            vragen_bestand.write("\n")
            vragen_bestand.write(vraag[1])
            vragen_bestand.write("\n")
            vragen_bestand.write("\n")

        if printen:
            print("Vraag " + str(vraag_nummer + 1) + ": " + vraag[0])
            print(vraag[1])
            print("\n")

    if opslaan:
        vragen_bestand.close()
    antwoorden_bestand.close()


main()



#aminozuur = kies_random_eiwit()
#
##De 3 noteringstypen mogen in deze vraagd gebruikt worden
#noteringstype = random.randint(0, 2)
#print("Wat is de 3D preferentie van aminozuur %s?" % aminozuur[noteringstype])
#eigenschap_antwoord = 6
#
##Creer keuzes
#juiste_keuze = aminozuur[eigenschap_antwoord]


##Met dank aan de hulp van Jeroen Merks voor het volgende stukje, die de volgorde van preferenties behoudt.
#alle_preferenties = [("Helix", False) , ("Strand", False), ("Turn", False), ("None", False)]
#
#counter = 0
#for preferentie, staat in alle_preferenties:
#    if preferentie[0] in juiste_keuze and len(juiste_keuze) == 1:
#        alle_preferenties[counter] = preferentie, True
#
#    elif preferentie[0] in juiste_keuze and len(juiste_keuze) > 1:
#
#
#    counter += 1
#
#print(random.shuffle([x[0][1] for x in alle_preferenties]))
#
#
#print(alle_preferenties)