Jak przekonwertować trzyliterowe kody aminokwasów na jeden kod literowy z pythonem lub R?

Question

Mam plik fasta, jak pokazano poniżej. Chciałbym przekonwertować kod three letter codes na kod jednoliterowy. Jak mogę to zrobić z pythonem lub R?

>2ppo 
ARGHISLEULEULYS 
>3oot 
METHISARGARGMET 

pożądane wyjście

>2ppo 
RHLLK 
>3oot 
MHRRM 

Państwa sugestie będą mile widziane !!

Answer 1

>>> src = "ARGHISLEULEULYS" 
>>> trans = {'ARG':'R', 'HIS':'H', 'LEU':'L', 'LYS':'K'} 
>>> "".join(trans[src[x:x+3]] for x in range(0, len(src), 3)) 
'RHLLK' 

Wystarczy dodać resztę wpisów do trans dict.

Edit:

Aby resztę trans, można to zrobić. File table:

Ala A 
Arg R 
Asn N 
Asp D 
Cys C 
Glu E 
Gln Q 
Gly G 
His H 
Ile I 
Leu L 
Lys K 
Met M 
Phe F 
Pro P 
Ser S 
Thr T 
Trp W 
Tyr Y 
Val V 

Przeczytaj go:

trans = dict((l.upper(), s) for l, s in 
      [row.strip().split() for row in open("table").readlines()]) 

Answer 2

używać słownika patrzeć kody jeden literę:

d = {'CYS': 'C', 'ASP': 'D', 'SER': 'S', 'GLN': 'Q', 'LYS': 'K', 
    'ILE': 'I', 'PRO': 'P', 'THR': 'T', 'PHE': 'F', 'ASN': 'N', 
    'GLY': 'G', 'HIS': 'H', 'LEU': 'L', 'ARG': 'R', 'TRP': 'W', 
    'ALA': 'A', 'VAL':'V', 'GLU': 'E', 'TYR': 'Y', 'MET': 'M'} 

a prostą funkcję, aby dopasować trzy kody nas z jednym kody liter dla całego ciągu znaków:

def shorten(x): 
    if len(x) % 3 != 0: 
     raise ValueError('Input length should be a multiple of three') 

    y = '' 
    for i in range(len(x)/3): 
      y += d[x[3*i:3*i+3]] 
    return y 

Testowanie przykład:

>>> shorten('ARGHISLEULEULYS') 
'RHLLK' 

Answer 3

Oto sposób, aby to zrobić w R:

# Variables: 
foo <- c("ARGHISLEULEULYS","METHISARGARGMET") 

# Code maps: 
code3 <- c("Ala", "Arg", "Asn", "Asp", "Cys", "Glu", "Gln", "Gly", "His", 
"Ile", "Leu", "Lys", "Met", "Phe", "Pro", "Ser", "Thr", "Trp", 
"Tyr", "Val") 
code1 <- c("A", "R", "N", "D", "C", "E", "Q", "G", "H", "I", "L", "K", 
"M", "F", "P", "S", "T", "W", "Y", "V") 

# For each code replace 3letter code by 1letter code: 
for (i in 1:length(code3)) 
{ 
    foo <- gsub(code3[i],code1[i],foo,ignore.case=TRUE) 
} 

Wyniki w:

> foo 
[1] "RHLLK" "MHRRM" 

Należy pamiętać, że zmieniłem nazwę zmiennej jako nazwy zmiennych nie można zaczynać od liczby w R.

Answer 4

Korzystanie z R:

convert <- function(l) { 

    map <- c("A", "R", "N", "D", "C", "E", "Q", "G", "H", "I", 
      "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V") 

    names(map) <- c("ALA", "ARG", "ASN", "ASP", "CYS", "GLU", "GLN", 
        "GLY", "HIS", "ILE", "LEU", "LYS", "MET", "PHE", 
        "PRO", "SER", "THR", "TRP", "TYR", "VAL") 

    sapply(strsplit(l, "(?<=[A-Z]{3})", perl = TRUE), 
     function(x) paste(map[x], collapse = "")) 
} 

convert(c("ARGHISLEULEULYS", "METHISARGARGMET")) 
# [1] "RHLLK" "MHRRM" 

Answer 5

Możesz spróbować patrząc i instalacji Biopython ponieważ jesteś parsowania pliku .fasta a następnie konwersję do jednego kodów literowych. Niestety, Biopython ma tylko funkcję seq3 (w pakiecie Bio :: SeqUtils), która ma odwrotność tego, co chcesz. Przykładowy wynik w IDLE:

>>>seq3("MAIVMGRWKGAR*") 
>>>'MetAlaIleValMetGlyArgTrpLysGlyAlaArgTer' 

Niestety, nie ma funkcji „seq1” (jeszcze ...), ale myślałem, że to może być pomocne dla Ciebie w przyszłości. Jeśli chodzi o twój problem, Junuxx jest poprawny. Utwórz słownik i użyj pętli for, aby odczytać ciąg w blokach po trzy i przetłumaczyć. Oto funkcja podobna do tej, którą zapewnił, że obejmuje wszystko, i obsługuje także mniejsze przypadki.

def AAcode_3_to_1(seq): 
    '''Turn a three letter protein into a one letter protein. 

    The 3 letter code can be upper, lower, or any mix of cases 
    The seq input length should be a factor of 3 or else results 
    in an error 

    >>>AAcode_3_to_1('METHISARGARGMET') 
    >>>'MHRRM' 

    ''' 
    d = {'CYS': 'C', 'ASP': 'D', 'SER': 'S', 'GLN': 'Q', 'LYS': 'K', 
    'ILE': 'I', 'PRO': 'P', 'THR': 'T', 'PHE': 'F', 'ASN': 'N', 
    'GLY': 'G', 'HIS': 'H', 'LEU': 'L', 'ARG': 'R', 'TRP': 'W', 'TER':'*', 
    'ALA': 'A', 'VAL':'V', 'GLU': 'E', 'TYR': 'Y', 'MET': 'M','XAA':'X'} 

    if len(seq) %3 == 0: 
     upper_seq= seq.upper() 
     single_seq='' 
     for i in range(len(upper_seq)/3): 
      single_seq += d[upper_seq[3*i:3*i+3]] 
     return single_seq 
    else: 
     print("ERROR: Sequence was not a factor of 3 in length!") 

Answer 6

my %aa_hash=(
    Ala=>'A', 
    Arg=>'R', 
    Asn=>'N', 
    Asp=>'D', 
    Cys=>'C', 
    Glu=>'E', 
    Gln=>'Q', 
    Gly=>'G', 
    His=>'H', 
    Ile=>'I', 
    Leu=>'L', 
    Lys=>'K', 
    Met=>'M', 
    Phe=>'F', 
    Pro=>'P', 
    Ser=>'S', 
    Thr=>'T', 
    Trp=>'W', 
    Tyr=>'Y', 
    Val=>'V', 
    Sec=>'U',      #http://www.uniprot.org/manual/non_std;Selenocysteine (Sec) and pyrrolysine (Pyl) 
    Pyl=>'O', 
); 


    while(<>){ 
      chomp; 
      my $aa=$_; 
      warn "ERROR!! $aa invalid or not found in hash\n" if !$aa_hash{$aa}; 
      print "$aa\t$aa_hash{$aa}\n"; 
    } 

użyć tego skryptu Perl konwertować trypletowe kody A.a na pojedynczym kodem literowym.

Answer 7

BioPython ma już wbudowane słowniki, które pomagają w takich tłumaczeniach. Następujące polecenia pokaże całą listę dostępnych słowników:

import Bio 
help(Bio.SeqUtils.IUPACData) 

Predefiniowane słowniku szukasz:

Bio.SeqUtils.IUPACData.protein_letters_3to1['Ala'] 

Answer 8

Biopython ma ładny rozwiązanie

>>> from Bio.PDB.Polypeptide import * 
>>> three_to_one('ALA') 
'A' 

Dla przykładu, Rozwiążę to przez tę jedną linijkę

>>> from Bio.PDB.Polypeptide import * 
>>> str3aa = 'ARGHISLEULEULYS' 
>>> "".join([three_to_one(aa3) for aa3 in [ "".join(g) for g in zip(*(iter(str3aa),) * 3)]]) 
>>> 'RHLLK' 

Mogą mnie skrytykować za tego typu jeden liniowiec :), ale w głębi duszy wciąż jestem zakochany w PERL.

Answer 9

Innym sposobem na to jest z pakietem w R.

# install.packages("seqinr") 
# source("https://bioconductor.org/biocLite.R") 
# biocLite("iPAC") 

library(seqinr) 
library(iPAC) 

#read in file 
fasta = read.fasta(file = "test_fasta.fasta", seqtype = "AA", as.string = T, set.attributes = F) 
#split string 
n = 3 
fasta1 = lapply(fasta, substring(x,seq(1,nchar(x),n),seq(n,nchar(x),n))) 
#convert the three letter code for each element in the list 
fasta2 = lapply(fasta1, function(x) paste(sapply(x, get.SingleLetterCode), collapse = "")) 

# > fasta2 
# $`2ppo` 
# [1] "RHLLK" 
# 
# $`3oot` 
# [1] "MHRRM" 

Answer 10

Dla tych, którzy wylądować tutaj na 2017 i poza seqinr i iPAC:

Oto jedna linia Linux komenda bash do konwersji białka aminokwas trzyliterowy kod do pojedynczego kodu literowego w pliku tekstowym. Wiem, że to nie jest zbyt eleganckie, ale mam nadzieję, że pomoże to komuś, kto będzie szukał tego samego i będzie chciał użyć polecenia pojedynczego wiersza.

sed 's/ALA/A/g;s/CYS/C/g;s/ASP/D/g;s/GLU/E/g;s/PHE/F/g;s/GLY/G/g;s/HIS/H/g;s/HID/H/g;s/HIE/H/g;s/ILE/I/g;s/LYS/K/g;s/LEU/L/g;s/MET/M/g;s/ASN/N/g;s/PRO/P/g;s/GLN/Q/g;s/ARG/R/g;s/SER/S/g;s/THR/T/g;s/VAL/V/g;s/TRP/W/g;s/TYR/Y/g;s/MSE/X/g' <input_file_three_letter_code.txt> output_file_single_letter_code.txt 

Roztwór do pierwotnego mowa powyżej, w jednej linii polecenia:

sed 's/.\{3\}/& /g' | sed 's/ALA/A/g;s/CYS/C/g;s/ASP/D/g;s/GLU/E/g;s/PHE/F/g;s/GLY/G/g;s/HIS/H/g;s/HID/H/g;s/HIE/H/g;s/ILE/I/g;s/LYS/K/g;s/LEU/L/g;s/MET/M/g;s/ASN/N/g;s/PRO/P/g;s/GLN/Q/g;s/ARG/R/g;s/SER/S/g;s/THR/T/g;s/VAL/V/g;s/TRP/W/g;s/TYR/Y/g;s/MSE/X/g' | sed 's/ //g' <input_file_three_letter_code.txt> output_file_single_letter_code.txt 

Objaśnienie:

[1] sed 's/.\{3\}/& /g' będzie spllit sekwencji. Dodaje spację po każdych 3 literach.

[2] Drugie polecenie "sed' w potoku zajmie wyjście powyższe i zamieni na kod jednoliterowy. Dodaj dowolne niestandardowe pozostałości jako s/XYZ/X/g; do tego polecenia.

[3] Trzecie polecenie "sed", sed 's/ //g' usunie białą przestrzeń.