[PYTHON] Erstellen Sie eine Proteinsequenz-Mutationsbibliothek mit Pandas
Einführung
Zweck
Bei der Untersuchung der Korrelation zwischen Proteinsequenz und Funktion Eine mutierte Sequenz, bei der eine beliebige Aminosäuremutation für eine bestimmte Proteinsequenz auf eine beliebige Stelle angewendet wird Ich habe es erstellt, weil ich es einfach generieren wollte. Es dient auch als Übung für Python, daher würde ich es begrüßen, wenn Sie mir andere oder bessere Methoden beibringen könnten.
GitHub https://github.com/kyo46n/Mutant-Library-Generator
Ausführungsumgebung
jupyter notebook python 3.7.4 (Anaconda) pandas 0.25.3 biopython 1.74
Inhalt
importieren
Angenommen, Sie haben die übergeordnete Proteinsequenz in einer Fasta-Datei Verwenden Sie Biopython zum Lesen und Schreiben von Dateien.
from Bio import SeqIO
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
import pandas as pd
Funktionsdefinition
Lesen Sie den Sequenznamen (id) und die Sequenz (seq) der Fasta-Datei im Wörterbuchtyp. Fügen Sie nach dem Konvertieren des seq-Teils in einen DataFrame mit einem Zeichen und einer Zeichenfolge die Sequenznamensspalte als Namen am linken Ende ein. Wenn es so bleibt, wie es ist, beginnt die Aminosäuresequenz bei 0 und die Position der Stelle weicht von der Intuition ab. 1 Korrigieren Sie den Spaltenindex am Anfang.
#fasta to dataframe
def fd(p):
d = {rec.id : list(str(rec.seq)) for rec in SeqIO.parse(p, "fasta")}
df = pd.DataFrame(d.values())
for i in d.keys():
name = i
df.insert(0, 'name', name)
df.iat[0, 0] = name
plus_one = {}
j = 1
for i in range(len(df.columns)+1):
plus_one[i] = j
j = j+1
df = df.rename(columns=plus_one)
return df
Als Funktion zur Grundberechnung Mit sdm (), das eine bestimmte Stelle in eine bestimmte Aminosäure umwandelt Erstellen Sie ssm (), das eine bestimmte Stelle in alle Aminosäuren konvertiert.
#for calculation of site directed mutagenesis
def sdm(df, site, mut):
df_mut = df.copy()
df_mut.iat[0, 0] = df_mut.iat[0,0] + "_" + df_mut.iat[0,site] + str(site) + mut
df_mut.iat[0,site] = mut
return df_mut
#for calculation of site saturation mutagenesis
def ssm(df, site):
aa_list = ['R', 'H', 'K', 'D', 'E', 'S', 'T', 'N', 'Q', 'C', 'G', 'P', 'A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W']
df_mut = df.copy()
for i in range(20):
df_mut = df_mut.append(df.iloc[0])
j = 1
for i in aa_list:
df_mut.iat[j, 0] = df_mut.iat[0,0] + "_" + df_mut.iat[0,site] + str(site) + i
df_mut.iat[j,site] = i
j = j + 1
df_mut.reset_index(drop=True,inplace=True)
return df_mut
Erstellen Sie isdm () und issm (), damit mehrere Varianten zusammen generiert werden können. Diese beiden Funktionen erzeugen eine Sequenz mit einer Mutation an einer beliebigen Stelle in einer separaten Zeile.
#individual site directed mutagenesis
def isdm(df, site_list, mut_list):
mylist = []
j = 0
for i in site_list:
mylist.insert(j, sdm(df, i, mut_list[j]))
j = j+1
df = pd.concat(mylist)
df = df.drop_duplicates(subset='name')
df.reset_index(drop=True,inplace=True)
return df
#individual site site saturation mutagenesis
def issm(df, site_list):
mylist = []
j = 0
for i in site_list:
mylist.insert(j, ssm(df,i))
j = j+1
df = pd.concat(mylist)
df = df.drop_duplicates(subset='name')
df.reset_index(drop=True,inplace=True)
return df
Erstellen Sie ssdm (), um eine Sequenz mit Mutationen an mehreren Stellen gleichzeitig zu generieren.
#simultaneous site directed mutagenesis
def ssdm(df, site_list, mut_list):
j = 0
for i in site_list:
df = sdm(df, i, mut_list[j])
j = j+1
return df
Erstellen Sie sssm (), um alle Kombinationen mehrerer Sättigungsmutationen zu generieren.
#simultaneous site saturation mutagenesis
def sssm(df, site_list):
for x in range(len(site_list)):
df_mut = df.copy()
templist = []
j = 0
for i in range(len(df_mut)):
dftemp = ssm(df_mut[i:i+1], site_list[x])
templist.insert(j, dftemp)
j = j + 1
df = pd.concat(templist)
df = df.drop_duplicates(subset='name')
df.reset_index(drop=True,inplace=True)
return df
Ausführungsbeispiel
Input.txt (Fasta-Format, ID: seq1 seq: MTIKE) wird als übergeordnetes Sequenzbeispiel vorbereitet. Lesen.
#read fasta
file = "input.txt"
df_wt = fd(file)
df_wt
Wenn Sie eine Variante mehrerer Sites generieren möchten ↓
site_list = [2,4,5]
mut_list = ["L","A","R"]
df_isdm = isdm(df_wt, site_list, mut_list)
df_isdm
Wenn Sie an mehreren Standorten gesättigte Varianten generieren möchten ↓ (Zum Beispiel gesättigte Varianten vom 2. bis 5.)
site_list = range(2,6)
df_issm = issm(df_wt, site_list)
df_issm
Wenn Sie eine Sequenz mit Mutationen an mehreren Stellen erzeugen möchten ↓
site_list = [2,4,5]
mut_list = ["L","A","R"]
df_ssdm = ssdm(df_wt, site_list, mut_list)
df_ssdm
Wenn Sie an mehreren Standorten eine Kombination gesättigter Varianten generieren möchten ↓
site_list = [2,3]
df_sssm = sssm(df_wt, site_list)
df_sssm
Duplikate verbinden und entfernen
Da es in der Forschung schwierig ist, es als ein Zeichen und eine Zeichenfolge zu belassen, kombinieren Sie es zu einem Array-Format und löschen Sie dasselbe Array.
df = df_sssm.copy()
df.insert(1, 'sequence', "-")
df.loc[:,'sequence'] = df[1].str.cat(df[range(2,len(df.columns)-1)])
df_seq = df.iloc[:,0:2]
df_seq = df_seq.drop_duplicates(subset='sequence')
df_seq.reset_index(drop=True,inplace=True)
df_seq
Export
Export nach CSV bzw. Fasta.
df_seq.to_csv("output.csv")
with open("output.txt", "w") as handle:
for i in range(len(df_seq.index)):
seq = Seq(df_seq.iloc[i,1])
rec = SeqRecord(seq, description="")
rec.id = df_seq.iloc[i,0]
SeqIO.write(rec, handle, "fasta")
abschließend
Ich habe das Gefühl, dass es viel Verschwendung gibt, Funktionen und Anweisungen für Anweisungen zu erstellen, aber vorerst kann ich die gewünschte Ausgabe erhalten.
Zukünftige Aufgaben
- Gemischte Einzelmutation und gesättigte Mutation (wenn "X", gesättigte Mutation ausführen)
- Verarbeitung mehrerer übergeordneter Arrays
- Verarbeitung eines großen Arrays (Verkürzung der Ausführungszeit)
- Code-Verfeinerung
Recommended Posts