¿Cómo convierto los códigos de tres letras de aminoácidos en un código de letra con python o R?

Question

Tengo un archivo fasta como se muestra a continuación. Me gustaría convertir el three letter codes al código de una letra. ¿Cómo puedo hacer esto con Python o R?

>2ppo 
ARGHISLEULEULYS 
>3oot 
METHISARGARGMET 

salida deseada

>2ppo 
RHLLK 
>3oot 
MHRRM 

sus sugerencias serán bienvenidos !!

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' 

sólo tiene que añadir el resto de las entradas a la trans dict.

Editar:

Para hacer que el resto de trans, se puede hacer esto. Archivo 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 

leerla:

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

Answer 2

usar un diccionario para buscar los códigos de una letra:

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'} 

y una función sencilla para que coincida con los códigos de tres letras con una sola códigos de letras para toda la cadena:

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 

Prueba de su ejemplo:

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

Answer 3

Aquí es una manera de hacerlo en I:

# 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) 
} 

Resultados en:

> foo 
[1] "RHLLK" "MHRRM" 

Tenga en cuenta que he cambiado el nombre de la variable como nombres de variables no pueden comenzar con un número en R.

Answer 4

Usando 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

Es posible que intente buscar en la instalación y Biopython ya que está analizando un archivo .fasta y luego convertir a códigos de una letra. Desafortunadamente, Biopython solo tiene la función seq3 (en el paquete Bio :: SeqUtils) que hace lo contrario de lo que quieres. Ejemplo de salida en IDLE:

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

Desafortunadamente, no hay ninguna función 'seq1' (todavía ...) pero pensé que esto podría ser útil para usted en el futuro. En cuanto a tu problema, Junuxx está en lo cierto. Cree un diccionario y use un ciclo for para leer la cadena en bloques de tres y traducir. Aquí hay una función similar a la que proporcionó, que es todo incluido y también maneja casos más bajos.

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"; 
    } 

Utilice este script en perl para convertir códigos a.a triplete al código de una letra.

Answer 7

BioPython ya tiene diccionarios incorporados para ayudar con tales traducciones. Después de comandos le mostrará una lista completa de los diccionarios disponibles:

import Bio 
help(Bio.SeqUtils.IUPACData) 

El diccionario predefinido que busca:

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

Answer 8

Biopython tiene una buena solución

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

Para su ejemplo, Lo resolveré con este trazador de líneas

>>> 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' 

Me pueden criticar por este tipo de trazador de líneas :), pero en lo profundo de mi corazón todavía estoy enamorado de PERL.

Answer 9

Otra forma de hacerlo es con el paquete seqinr y iPAC en 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

Para los que la tierra aquí en 2017 y más allá:

Aquí hay una sola línea de comandos bash de Linux para convertir las proteínas código de tres letras de aminoácido al código de una sola letra en un archivo de texto. Sé que esto no es muy elegante, pero espero que esto ayude a alguien a buscar lo mismo y quiera usar el comando de una sola línea.

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 

Solución para la pregunta original anterior, como una única línea de comando:

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 

Explicación:

[1] sed 's/.\{3\}/& /g' se spllit la secuencia. Agregará un espacio después de cada 3ª letra.

[2] El segundo comando 'sed' en la tubería tomará la salida anterior y convertirá a código de una sola letra. Agregue cualquier residuo no estándar como s/XYZ/X/g; a este comando.

[3] El tercer comando 'sed', sed 's/ //g' eliminará el espacio en blanco.