Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #!/usr/bin/python
- from collections import Counter
- import os
- """
- De functie opent de opgegeven filenaam, wat als een parameter meegegeven wordt,
- en keert alle zinnen als een lijst terug. Ze zijn gesprlitst op een enter.
- De functie gebruikt de volgende parameters:
- * of_file bestand van interesse dat geopend moet worden.
- """
- def OpenFile(of_file):
- with open(of_file, 'r') as f:
- return f.readlines()
- """
- De functie kijkt of de opgegeven waarde (if_kans) in de lijst (if_lijst)
- voorkomt. Als datwaar is dat wordt de waarde "true teruggegeven, zoniet dat
- wordt de waarde "False" teruggegeven.
- De functie gebruikt de volgende parameters (op volgorde):
- * if_kans mogelijke combinatie van tekens.
- * if_lijst lijst waar er in gezocht moet worden.
- """
- ##TODO:
- # deze functie is best wel bullshit
- def IndexFind(if_kans, if_lijst):
- try:
- if_lijst.index(if_kans)
- return True
- except ValueError:
- return False
- """
- De functie doorloopt de lijst, twogdeellijst (dat teruggeleverd wordt door
- de functie OpenFile) en zorgt ervoor dat elke mogelijke combinatie maar 1 maal
- voorkomt. Dit is nodig omdat er soms bij de blastresultaten meerdere malen voor
- kan komen dat een bepaalde beste hit voor kan komen. Alle mogelijke combinaties
- worden dan als een lijst teruggekeerd.
- De functie gebruikt de volgende parameters (op volgorde):
- * br_naam1 organisme naam van het eerste deel
- * br_naam2 organisme naam van het tweede deel
- * br_pos1 positie
- * br_pos2 positie
- de posities kunnen alleen of 0 of 1 zijn. Als br_pos1 een 1 heeft, dan moet
- br_pos2 de 0 hebben!
- De functie keert het volgende terug:
- * singles.keys() lijst van alle mogelijke combinaties
- """
- def BlastResults(br_naam1, br_naam2, br_pos1, tbr_pos2):
- singles = {}
- twogdeellijst = OpenFile(br_naam1 + br_naam2)
- for zin in twogdeellijst:
- singles[(zin.split()[br_pos1] + " " + zin.split()[br_pos2])] = 0
- return singles.keys()
- """
- De functie zorgt ervoor dat in de file genaamd Twogs nieuwe twogcombinaties
- bijgevoegd kunnen worden. De combinatie worden erkregen door een in een lege
- lijst de mogelijke combinaties toe te voegen. De combinaties worden verkregen
- door de functie Blastresult. als de lijst gevuld wordt, zullen het aantal
- mogelijke combinaties geteld worden. Als de combinatie >= 2 dan wordt de
- combinatie in de twoglijst gevuld.
- Hierna wordt de file afgesloten.
- De functie gebruikt de volgende parameters (op volgorde):
- * snt_naam1 organisme naam van het eerste deel
- * snt_naam1 organisme naam van het tweede deel
- """
- def SchrijfNaarTwog(snt_naam1, snc_naam2):
- snt_twogfile = open("Twogs", "a")
- snt_lijst = []
- snt_lijst.extend(BlastResults(snt_naam1, snc_naam2, 0, 1))
- snt_lijst.extend(BlastResults(snc_naam2, snt_naam1, 1, 0))
- tellijst = Counter(snt_lijst)
- for keys in tellijst:
- if tellijst[keys] >= 2:
- snt_twogfile.write("%s\n" % (keys))
- snt_twogfile.close()
- """
- De functie zorgt ervoor dat in de file genaamd cogs.txt nieuwe eiwitten met hun
- cognummerscogs toegevoegd kunnen worden
- Hierna wordt de file afgesloten.
- De functie gebruikt de volgende parameters:
- * vtav_lijst Lijst van alle mogelijke eiwitten en hun cognummers.
- """
- #TODO:
- #Als je bij open() de "a" verandert in "w", krijg je geen dubbele waardes als /
- # je het script meerdere keren runt. Ook duurt het runnen van het progje dan /
- # minder lang
- def VoegToeAanCog(vtav_lijst):
- cogfile = open("cogs.txt", "a")
- for zin in vtav_lijst:
- cogfile.write(zin)
- cogfile.close()
- """
- de functie schrijft naar de file Twogs. Hij nneemt alle posities in de lijst
- en schrijft ze naar de file. Daarna wordt de file afgesloten.
- De functie gebruikt de volgende parameters :
- * ntf_twogs lijst van twogs
- """
- def NewTwogFile(ntf_twogs):
- outfile = open("Twogs", "w")
- for x in ntf_twogs:
- outfile.write("%s\n" % (x))
- outfile.close()
- """
- De functies zorgt ervoor dat van de twogslijst alle mogelijke combinaties
- verwijderd worden.
- De functie gebruikt de volgende parameters (op volgorde):
- * tr_twoglijst lijst van mogelijke twogs die verwijderd moeten worden.
- * tr_twogs lijst van alle twog combinatie.
- """
- def TwogRemove(tr_twoglijst, tr_twogs):
- for b in tr_twoglijst:
- tr_twogs.remove(b)
- """
- De functie zorgt ervoor dat er in een lijst gezocht wordt.
- De functie gebruikt de volgende parameters (op volgorde):
- * zil_waarde waarde wat aanwezig moet zijn in de lijst.
- * zil_lijst lijst wat gezocht moet worden.
- * zil_switch de mogelijkheid om een bepaalde lijst te doorzoeken.
- De functie keert het volgende terug:
- * de lijsten van interresse
- """
- def ZoekInLijst(zil_waarde, zil_lijst, zil_switch):
- if zil_switch == 0:
- return [x for x in zil_lijst if zil_waarde in x]
- elif zil_switch == 1:
- return [x.split()[0] for x in zil_lijst if zil_waarde in x]
- elif zil_switch == 2:
- return [x.split()[1] for x in zil_lijst if zil_waarde in x]
- """
- De functie update een bestaande cog. Als er een eiwit gevonden wordt dat bij
- een bepaalde cogs hoort, wordt in de twoglijst naar alle mogelijke combinaties
- gezocht en worden ze (alle combinaties die bij de desbetreffende cog hoort)
- verwijderd uit de twoglijst. Tevens wordt dan ook de eiwit uit de protlijst
- verwijderd.
- De functie heeft 3 verschillende parameters nodig (op volgorde):
- * cogs coglijst
- * twogs twoglijst
- * prots protlijst
- """
- #TODO:
- #Kan, maar is beetje bullshit want is letterlijkwaar 3 regels en een for-loopje
- def CogUpdate(cogs, twogs, prots):
- cu_in_lijst_toevoegen = []
- for x in list(set([y.split()[0] for y in cogs])):
- cu_gevondencog = ZoekInLijst(x, cogs, 2)
- cu_lijstje = []
- nogteverwijderen = []
- for y in cu_gevondencog:
- cu_lijstje.extend(ZoekInLijst(y, twogs, 2))
- nogteverwijderen.extend(ZoekInLijst(y, twogs, 0))
- if len(Counter(cu_lijstje)) != 0:
- max_prot = KeyWithMaxVal(dict(Counter(cu_lijstje)))
- cu_in_lijst_toevoegen.append("%s\t%s\n" % (x, max_prot))
- prots.remove(max_prot)
- nogteverwijderen.extend(ZoekInLijst(max_prot, twogs, 0))
- newlijst = list(set(nogteverwijderen))
- TwogRemove(newlijst, twogs)
- VoegToeAanCog(cu_in_lijst_toevoegen)
- """
- De functie doorzoekt de twoglijst en vindt alle mogelijke combinaties van de
- eiwitten in de kleine lijst (prot_in_twogs). De combinaties worden allemaal
- opgeslagen in de lokale variabel genaamd:
- vt_lijst
- De functie heeft 3 parameters:
- * prot het eiwit van interresse
- * twogs de twoglijst
- * prot_in_twogs de lijst van de nodige eiwitten
- De functie keert het volgende terug:
- * vt_lijst lijst van interresse
- """
- #TODO:
- #IndexFind is best wel bullshit. Alsje gewoon if_lijst.index(if_kans) bij de if- heb je hetzelfde uitkomst.
- def VerbrogenTwogs(prot, twogs, prot_in_twogs):
- vt_lijst = []
- for x in prot_in_twogs:
- for y in prot_in_twogs:
- if IndexFind("%s %s" % (x, y), twogs):
- vt_lijst.append("%s %s" % (x, y))
- vt_lijst.append("%s %s" % (x, prot))
- vt_lijst.append("%s %s" % (y, prot))
- return vt_lijst
- """
- De functie maakt een nieuwe cog aan. De functie zorgt ervoor dat als eerste
- het hoogste bekende cognummer opgehaald wordt door de functie
- "VindHoogsteCogNummer".
- De functie doorloopt de eiwttenlijst en zoekt in de twoglijst naar alle
- mogelijke combinatie behorend bij het eiwit. Waarna de functie "VerbrogenTwogs"
- aangeroepen wordt. het resultaat wordt in de variabele posible_found_twogs
- gezet. als deze variabele niet leeg is dan worden alle eiwitten in een nieuwe
- variabele lijst (newcog) gestopt. Hier wordt per eiwit in de lijst dezelfde
- cognummer toegekend. Alle mogelijke combinatie van twogs dat nog aanwezig is
- in de twoglijst wordt ook meteen verwijderd.
- Als laatste wordt de lijst met de nieuwe cognummer aan de cogfile toegevoegd.
- Dit gebeurt door middel van de functie "VoegToeAanCog".
- De functie heeft 3 verschillende parameters nodig (op volgorde):
- * ncf_cogs coglijst
- * ncf_twogs twoglijst
- * ncf_prots protlijst
- """
- #TODO:
- #vindhoogtecognummer kan, maar is beetje bs want 1 try en 3 excepts, dus kan \
- # makkelijker.
- def NewCogFind(ncf_cogs, ncf_twogs, ncf_prots):
- coglijst_hoogste_waarde = list(set([y.split()[0] for y in ncf_cogs]))
- werkgetal = VindHoogsteCogNummer(coglijst_hoogste_waarde)
- ncf_list = []
- for prot in ncf_prots:
- prot_in_twogs = ZoekInLijst(prot, ncf_twogs, 1)
- posible_found_twogs = VerbrogenTwogs(prot, ncf_twogs, prot_in_twogs)
- if posible_found_twogs != []:
- newcog = list(set(" ".join(posible_found_twogs).split()))
- werkgetal += 1
- for incog in newcog:
- cogzin = "%s\t%s\n" % (
- ("0000000000%s" % (werkgetal))[-8:], incog)
- ncf_list.append(cogzin)
- TwogRemove(ZoekInLijst(incog, ncf_twogs, 0), ncf_twogs)
- VoegToeAanCog(ncf_list)
- """
- de functie keert het hoogste cognummer. Bestaat het nummer niet dan zal de
- waarde 0 teruggegeven worden.
- De functie gebruikt de volgende parameters :
- * vhcn_lijst lijst waar er in gezocht moet worden.
- De functie keert een getal terug
- """
- #TODO:
- #beetje bullshit, zie vorige functie
- def VindHoogsteCogNummer(vhcn_lijst):
- try:
- return int(max(vhcn_lijst)[0])
- except IOError:
- return 0
- except IndexError:
- return 0
- except ValueError:
- return 0
- """
- de functie keert de key van een dictionary waarbij de waarde de maximale waarde
- heeft.
- De functie gebruikt de volgende parameters :
- * kwmv_dict dictionairy waar erin gezocht wordt
- De functie keert key terug waarbij de value een hoogste maximale waarde heeft
- """
- def KeyWithMaxVal(kwmv_dict):
- values = list(kwmv_dict.values())
- keys = list(kwmv_dict.keys())
- return keys[values.index(max(values))]
- """
- De functie doorzoekt:
- de protlijst, van de fastafile worden alleen de regels
- waar een ">" in voorkomt gepakt.
- de twoglijst
- de coglijst
- De functie gebruikt de volgende parameters :
- * onf_org organismenaam
- de functie keert (op volgorde) de volgende 3 lijsten terug:
- * protlijst
- * twoglijst
- * coglijst
- """
- def OpenNeededFiles(onf_org):
- protlijst = [y[1:-1] for y in OpenFile("%s.fa" % (onf_org)) if ">" in y]
- twoglijst = [y[:-1] for y in OpenFile("Twogs")]
- coglijst = [y[:-1] for y in OpenFile("cogs.txt")]
- return protlijst, twoglijst, coglijst
- """
- De functie doorzoekt in de cogs en in de twogs of de bestaande cogs geupdate
- moeten worden of dat er nieuwe cogs moeten onstaan. tevens zorgt het ervoor
- dat de twogfile geheel vernieuwe wordt.
- De functie gebruikt de volgende parameters (op volgorde):
- * sfc_cogs coglijst
- * sfc_twogs twoglijst
- * sfc_prots protlijst
- """
- def SearchForCog(sfc_cogs, sfc_twogs, sfc_prots):
- CogUpdate(sfc_cogs, sfc_twogs, sfc_prots)
- NewCogFind(sfc_cogs, sfc_twogs, sfc_prots)
- NewTwogFile(sfc_twogs)
- """
- de functie zorgt ervoor dat de cogs gemaakt worden van de bijgeleverde files.
- Voor elk nieuwe organisme wordt de naam van het organisme geprint
- Let op: bestaande files zoals de twogs en de cogs.txt zullen verwijderd worden!
- """
- #TODO:
- #ik zou del gebruiken enz, niet os.system
- def Voorbeeld():
- os.system("rm Twogs cogs.txt")
- os.system("touch Twogs cogs.txt")
- orgslijst = [y[:-1] for y in OpenFile("orglijst") if "\n" in y]
- for x in range(len(orgslijst)):
- org1 = orgslijst[x]
- for y in range(len(orgslijst)):
- org2 = orgslijst[y]
- if x > y:
- SchrijfNaarTwog(org1, org2)
- print
- org1
- prots, twogs, cogs = OpenNeededFiles(org1)
- if x >= 2:
- SearchForCog(cogs, twogs, prots)
- if __name__ == '__main__':
- Voorbeeld()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement