Wie konvertiere ich die drei-Buchstaben-Aminosäure-codes zu einem Buchstaben-code mit python-oder R?

BioPython verfügt bereits über integrierte Wörterbücher zu helfen, mit solchen übersetzungen. Folgende Befehle zeigen Sie eine Liste Verfügbarer Wörterbücher:

import Bio
help(Bio.SeqUtils.IUPACData)

Die eingebauten dictionary-Sie suchten:

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

Hier ist ein Weg, es zu tun in 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)
}

Ergebnisse in :

> foo
[1] "RHLLK" "MHRRM"

Beachten Sie, dass ich änderte den Namen der Variablen als Variablen-Namen dürfen nicht mit einer Zahl beginnen, in R.

Können Sie versuchen, die Suche in und die Installation Biopython da Sie Parsen ein .fasta-Datei und dann Umwandlung in eine Buchstaben-codes. Leider Biopython nur die Funktion hat, seq3(im Paket Bio::SeqUtils), die nicht die inverse von dem, was Sie wollen. Beispiel für die Ausgabe im LEERLAUF:

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

Leider, es gibt keine "seq1" - Funktion (noch nicht...), aber ich dachte, das könnte hilfreich sein, um Sie in der Zukunft. Soweit Ihr problem, Junuxx korrekt ist. Erstellen Sie ein Wörterbuch und verwenden Sie eine for-Schleife zum Lesen der string in Blöcke von drei und übersetzen. Hier ist eine ähnliche Funktion wie die, die er zur Verfügung gestellt ist all-inclusive und Griffe untere Fällen als gut.

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!")

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"

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

Verwenden Sie dieses perl-Skript zum konvertieren Drilling ein.a-codes um einzelne Buchstaben-code.

Python 3 Lösungen.

In meiner Arbeit, die genervt ist, dass man die Aminosäure-codes beziehen können, um die modifizierten, die oft erscheinen in der PDB/mmCIF-Dateien, wie

'Tih'-->'A'.

So kann sich das mapping mehr als 22 Paare. Die 3rd-party-tools in Python-wie

Bio.SeqUtils.IUPACData.protein_letters_3to1

kann nicht damit umgehen. Meine einfachste Lösung ist die Nutzung der http://www.ebi.ac.uk/pdbe-srv/pdbechem zu finden, die Zuordnung und Beurteilung der ungewöhnliche Zuordnung zu den dict-in meinem eigenen Funktionen, Wann immer ich Ihnen begegnen.

def three_to_one(three_letter_code):
    mapping = {'Aba':'A','Ace':'X','Acr':'X','Ala':'A','Aly':'K','Arg':'R','Asn':'N','Asp':'D','Cas':'C',
           'Ccs':'C','Cme':'C','Csd':'C','Cso':'C','Csx':'C','Cys':'C','Dal':'A','Dbb':'T','Dbu':'T',
           'Dha':'S','Gln':'Q','Glu':'E','Gly':'G','Glz':'G','His':'H','Hse':'S','Ile':'I','Leu':'L',
           'Llp':'K','Lys':'K','Men':'N','Met':'M','Mly':'K','Mse':'M','Nh2':'X','Nle':'L','Ocs':'C',
           'Pca':'E','Phe':'F','Pro':'P','Ptr':'Y','Sep':'S','Ser':'S','Thr':'T','Tih':'A','Tpo':'T',
           'Trp':'W','Tyr':'Y','Unk':'X','Val':'V','Ycm':'C','Sec':'U','Pyl':'O'} # you can add more
    return mapping[three_letter_code[0].upper() + three_letter_code[1:].lower()]

Die andere Lösung ist das abrufen der mapping-online (Aber die url und die html-Muster kann sich ändern durch die Zeit):

import re
import urllib.request

def three_to_one_online(three_letter_code):
    url = "http://www.ebi.ac.uk/pdbe-srv/pdbechem/chemicalCompound/show/" + three_letter_code
    with urllib.request.urlopen(url) as response:
        single_letter_code = re.search('\s*<td\s*>\s*<h3>One-letter code.*</h3>\s*</td>\s*<td>\s*([A-Z])\s*</td>', response.read().decode('utf-8')).group(1)
    return single_letter_code

Hier habe ich direkt die re statt den html-Parser für die Einfachheit.

Hoffe, dass diese helfen können.