[PYTHON] Créer une bibliothèque de mutations de séquences protéiques avec des pandas
introduction
Objectif
En étudiant la corrélation séquence-fonction des protéines Une séquence mutante dans laquelle une mutation arbitraire d'acide aminé est appliquée à un site arbitraire pour une certaine séquence protéique Je l'ai créé parce que je voulais le générer facilement. Cela sert également de pratique pour python, donc je vous serais reconnaissant si vous pouviez m'apprendre d'autres méthodes ou de meilleures méthodes.
GitHub https://github.com/kyo46n/Mutant-Library-Generator
Environnement d'exécution
jupyter notebook python 3.7.4 (Anaconda) pandas 0.25.3 biopython 1.74
Contenu
importer
En supposant que vous ayez la séquence de protéine parente dans un fichier fasta Utilisez biopython pour lire et écrire des fichiers.
from Bio import SeqIO
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
import pandas as pd
Définition des fonctions
Lire le nom de la séquence (id) et la séquence (seq) du fichier fasta dans le type dictionnaire, Après avoir converti la partie seq en un DataFrame avec un caractère et une chaîne, insérez la colonne de nom de séquence comme nom à l'extrémité gauche. Si elle est laissée telle quelle, la séquence d'acides aminés commencera à 0 et la position du site s'écartera de l'intuition. 1 Corrigez l'index de colonne au début.
#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
En fonction du calcul de base Avec sdm () qui convertit un site spécifique en un acide aminé spécifique Créez ssm () qui convertit un site spécifique en tous les acides aminés.
#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
Créez isdm () et issm () afin que plusieurs variantes puissent être générées ensemble. Ces deux fonctions génèrent une séquence avec une mutation à n'importe quel endroit dans une ligne séparée.
#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
Créez ssdm () pour générer une séquence avec des mutations à plusieurs endroits en même temps.
#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
Créez sssm () pour générer toutes les combinaisons de plusieurs mutations de saturation.
#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
Exemple d'exécution
Input.txt (format fasta, id: seq1 seq: MTIKE) est préparé en tant qu'échantillon de séquence parent. Lis.
#read fasta
file = "input.txt"
df_wt = fd(file)
df_wt
Si vous souhaitez générer une variante de plusieurs sites ↓
site_list = [2,4,5]
mut_list = ["L","A","R"]
df_isdm = isdm(df_wt, site_list, mut_list)
df_isdm
Si vous souhaitez générer des variantes saturées sur plusieurs sites ↓ (Par exemple, variantes saturées du 2e au 5e)
site_list = range(2,6)
df_issm = issm(df_wt, site_list)
df_issm
Si vous souhaitez générer une séquence avec des mutations sur plusieurs sites ↓
site_list = [2,4,5]
mut_list = ["L","A","R"]
df_ssdm = ssdm(df_wt, site_list, mut_list)
df_ssdm
Si vous souhaitez générer une combinaison de variantes saturées sur plusieurs sites ↓
site_list = [2,3]
df_sssm = sssm(df_wt, site_list)
df_sssm
Rejoindre et supprimer les doublons
Puisqu'il est difficile à utiliser dans la recherche s'il reste un caractère et une chaîne, combinez-le dans un format de tableau et supprimez le même tableau.
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
exportation
Exporter respectivement vers csv et 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")
en conclusion
Je pense qu'il y a beaucoup de gaspillage dans la façon de créer des fonctions et autour des déclarations, mais pour le moment, je peux obtenir le résultat que je veux.
Tâches futures
--Mutation unique mélangée et mutation saturée (si "X", exécuter une mutation saturée)
- Traitement de plusieurs tableaux parents --Traitement d'un énorme tableau (raccourcissement du temps d'exécution)
- Raffinement du code
Recommended Posts