def codons(s, frame=0):
    """Return a list of codons from a string, s, giving an optional frameshift."""

    codons=[]

    end=len(s[frame:]) - (len(s[frame:]) % 3) - 1

    for i in range(frame,end,3):
        codons.append(s[i:i+3])

    return codons

from Bio import Translate
translater=Translate.unambiguous_dna_by_id[11]
bacterial_table=translater.table.forward_table

Note 1: See the NCBI Translation Tables for the correctid number to use for your sequence.

bacterial_table['TAT']
>>>'Y'

And here’s how to easily reverse it, where the keys are amino acids and the values are lists of codons:

back_table = {}
for key,value in bacterial_table.iteritems():
    try:
        back_table[value].append(key)
    except KeyError:
        back_table[value]=[key]

Getting a FASTA file into Python is as simple as importing the necessary functions from BioPython, opening the file, and calling a parser on the file. Then you have sequences in BioPython that can be readily used. There are a couple of different ways to parse the file, depending on your preference. Choices are:

• iterator (saves memory, but only one sequence in memory at a time so you can’t randomly choose one)
• list (takes up memory, but you can access each sequence using an index)
• dictionary (takes up memory and a few more lines of code to make, but you can access each sequence by its accession number rather than its position in a list)

Do something to each record in a FASTA file (iterator method)

Use the following code for when you want to operate on each sequence in a fasta file and then move onto the next one. This brings in one sequence at a time, operates on it, then removes it from Python. Very memory efficient, but the sequences are not retained in Python.

from Bio import SeqIO
f = open(FASTfilename)
for i in SeqIO.parse(f,'fasta')
   print i.id
   print i.seq
   print len(i.seq)
f.close()

Make a list of Seq objects from a FASTA file (list method)

This returns a list of sequence objects, seq_list, from the fasta file. This is not as memory efficient as the code above, but the sequences are available in the list after parsing the file.

from Bio import SeqIO
f=open(FASTAfilename)
seq_list=list(SeqIO.parse(f,"fasta")
f.close()

Import into a flat database (dictionary method)

Sometimes it’s more useful to access a sequence by its accession number rather than by its position in a list. Use the Seq.to_dict() function to do this. However, using this function directly results in the keys of the dictionary being the whole description line of a fasta record (this behavior is different for GenBank files). You can provide your own function (anything that operates on a SeqRecord object). Whatever is returned from this record will be the key for the record in the dictionary. Below is a function to return the accession number of a record.

def get_accession(record):
    """Given a SeqRecord, return the accession number as a string
        e.g. gi|2765613|emb|Z78488.1|PTZ78488 -> Z78488.1    """
    parts=record.id.split("|")
    assert len(parts)==5 and parts[0]=="gi" and parts[2]=="emb"
    return parts[3]

Then, provide the SeqIO.to_dict() function below with the get_accession() function defined above. The result is a dictionary of sequence objects, keyed by accession (or whatever you told your key function to return — species perhaps? Or GI number?)

from Bio import SeqIO
f=open(FASTAfilename)
d=SeqIO.to_dict(SeqIO.parse(f,"fasta"),key_function=get_accession)
f.close()

Now you have a dictionary of FASTA records, keyed by accession number which you can use like so:

d['Z78488.1']  # --> a Seq object

Create a sequence

This is the most basic way of getting a sequence. Usually sequences will come in as GenBank or Fasta files, but it’s useful to know how to create a sequence from scratch.

Sequences need data (the sequence) and an alphabet. The alphabet is what distinguishes a DNA sequence from an amino acid sequence or RNA sequence (see sequence alphabets below).

Create a nucleotide sequence from scratch

Note that once a sequence is created, it cannot be changed. This is to ensure that anything the code that manipulates sequences will not change them. If you do want to change a sequence (say, change the first A to a T), then you must create a Mutable Seq

from Bio.Seq import Seq
from Bio.Alphabet import IUPAC

s = Seq('ACGTACTGGCATGTGCA', IUPAC.unambiguous_dna)

What makes this sequence a DNA sequence is the unambiguous_dna alphabet. BioPython now knows ACGT stands for the nucleotides (adenine, cytosine, guanine, and thymine), not the amino acids (alanine, cysteine, glycine, and threonine).

Create a protein sequence from scratch

As you might guess, same as the nucleotide sequence, but use a protein alphabet instead.

from Bio.Seq import Seq
from Bio.Alphabet import IUPAC

s = Seq('ACGTACTGGCATGTGCA',IUPAC.protein)

To create another kind of sequence, use another alphabet (see sequence alphabets below for other alphabets).

Get the complement of a sequence

After creating the sequence, s, from above, use the complement() method of the Seq object.

s.complement()

Output:
Seq('TGCATGACCGTACACGT', IUPACUnambiguousDNA())

Note that the resulting sequence has the same alphabet as the original sequence.

Transcribe a sequence

The BioPython Transcribe package can transcribe sequences.

from Bio import Transcribe
from Bio.Seq import Seq
from Bio.Alphabet import IUPAC

trans=Transcribe.unambiguous_transcriber

s = Seq('ACGTACTGGCATGTGCA',IUPAC.unambiguous_dna)

rna = trans.transcribe(s)

The output, rna, is a Seq object:

Output:
Seq('ACGUACUGGCAUGUGCA', IUPACUnambiguousRNA())

There is also an ambiguous_dna transcriber.

Translate a sequence

Here’s how to translate a

from Bio import Translate
from Bio.Seq import Seq
from Bio.Alphabet import IUPAC

trans=Translate.unambiguous_dna_by_id[11]
s = Seq('ACGTACTGGCATGTGCA',IUPAC.unambiguous_dna)
pep=trans.translate(s)

Sequence Alphabets

When working with BioPython sequences, sometimes you have to specify the alphabet of the sequence. The alphabets for creating sequences (or setting the alphabet of an imported FASTA sequence) can be found in the Bio.Alphabet.IUPAC module. IUPAC stands for the International Union of Applied and Pure Chemistry, an organization which defined standard nomenclature for things like nucleic acids and amino acids (references here).

from Bio.Alphabet import IUPAC
my_alphabet = IUPAC.unambiguous_dna

• unambiguous_dna
• • GATC
• ambiguous_dna
• • GATCRYWSMKHBVDN
• protein
• • ACDEFGHIKLMNPQRSTVWY
• extended_protein
• • ACDEFGHIKLMNPQRSTVWYBXZ
• unambiguous_rna
• • GAUC
• ambiguous_rna
• • GAUCRYWSMKHBVDN
• extended_dna
• • GATCBDSW

see class diagram of BioPython alphabets for more details.

There is also support for a reduced alphabet (from Bio.Alphabet import Reduce). Check the source code for useful documentation on this alphabet, which combines physiochemically similar amino acids into a single letter.

Examples of using Seq objects

s = Seq('ACGTACTGGCATGTGCA',IUPAC.unambiguous_dna)

# length of the sequence
len(s)

# number of A's
s.count('A')

# GC content
GC = s.count('G')+s.count('C')
GC_percent = float(GC) / len(s) * 100

# a subsequence
s[3:6]

For more advanced operations, the Seq object needs to be converted to a string. Luckily, the tostring() method of a Seq object does just that.

# find all occurences where EITHER G or C is found before T

import re
matches = re.findall('[GC]T',s.tostring())

There are two separate parts to consider when you want to get blast results: running the BLAST search, and parsing the results. If you prefer, you can run a BLAST search on NCBI the normal way through NCBI’s web site. Just make sure to save the results as an XML file. Then you can skip to Part 2.

I’m going to assume you have a sequence of interest called sequence. It should be in a string format (if you have a Seq object, use Seq.data to get the string. If you have a SeqRecord object, use SeqRecord.seq.data to get the string). Need a sequence? Here’s one to play around with.

# Homo sapiens hemoglobin, beta subunit
sequence = """MVHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKVKAHGKKVLG
AFSDGLAHLDNLKGTFATLSELHCDKLHVDPENFRLLGNVLVCVLAHHFGKEFTPPVQAAYQKVVAGVAN
ALAHKYH"""

# remove newlines, just in case
sequence = sequence.replace("\n","")

Part 1: Running the BLAST search

The sequence is sent to NCBI’s QBLAST server for a blastp search (the protein version of BLAST) using the non-redundant (nr) database. When the search is done, we get a file-like object in return. The great part: Python takes care of the waiting, and downloads it as soon as it’s ready.

from Bio.Blast import NCBIWWW

# this is the actual blast search, so it may take a moment
blast_handle = NCBIWWW.qblast('blastp', 'nr', sequence)

Done! Now you’re ready for parsing the results (see Part 2 below). The rest of this section goes over optional saving of the blast results to a string or file.

Some optional bits

WARNING: blast_handle is a StringIO object, which is a special kind of string that acts like a file. Like files, StringIO objects only read each line once. So if you were to print blast_handle, it would run through its contents. If you were to try printing it again, you would see nothing, because it has already exhausted its contents by the first printing. How do you fix this? Like so:

# rewind blast_handle back to the beginning
blast_handle.seek(0)

Alternatively, you could save it as a string:

# optional: save the result as a string (rewind to the beginning first)
blast_handle.seek(0)
blast_string = blast_handle.read()

Here’s how to save it as a file on disk:

# optionally save blast_handle as a file for later use
blast_handle.seek(0)
blast_file = open('blast-output.xml', 'w')
blast_file.write(blast_handle.read())
blast_file.close()

Part 2: Analyzing the BLAST results

Open a file or use a StringIO object

If you have an XML file that you’re going to parse (either from the NCBI web site or from saving the results from above), first you need to open the file:

# If you're using a file on disk:
filename = 'blast-output.xml'
parse_me = open(filename)

Otherwise, you can use the blast_handle from above. To keep the code consistent, I’ll set up a parse_me variable:

# If you're using the results directly from the BLAST query:
parse_me = blast_handle
parse_me.seek(0)

Parse it

OK, let’s parse that puppy:

from Bio.Blast import NCBIXML
records = NCBIXML.parse(file_handle)

records is an iterator. Each item corresponds to a record in the BLAST results. If you used the NCBI web site, you could have pasted in several FASTA records. In this case, records will have several records in it. If, on the other hand, you sent a single sequence to QBLAST as in Part 1, then records will only contain a single record.

Single-record GenBank files

Use this method if there is only a single record in the GenBank file. If there are multiple records, then use the “Iterate over several records” method below.

# Read a single GenBank record in a file into BioPython

from Bio import GenBank
feature_parser = GenBank.FeatureParser()  #create the parser object
gb_file = "AE017199.gbk"  #specify a genbank file

# Note the parser needs an open file object.
gb_record = feature_parser.parse(open(gb_file,"r"))

Iterate over several records

If there are several records in the file, then you can iterate over them. Here’s how:

# Iterate over multiple GenBank records in a single file.

from Bio import GenBank

# open the GenBank file
gb_file = "cor6_6.gb"
gb_handle = open(gb_file, "r")

feature_parser = GenBank.FeatureParser()

gb_iterator = GenBank.Iterator(gb_handle, feature_parser)

while True:
    rec = gb_iterator.next()  #see Note 1
    if rec is None:
        break
    # whatever you want to do to the sequence goes here.
    # In this example, the name, number of features,
    # and sequence itself are printed.
    print "Name: %s, %i features" % (rec.name, len(rec.features))
    print rec.seq

Note 1: the next() method grabs the next item in the iterator. If there’s nothing left in the iterator (that is, it’s already returned its last item) then it returns a None. Iterators are very memory efficient but need a little extra code to avoid errors.back to code

Parse a GenBank file into a dictionary

By parsing a GenBank file into a dictionary, you can access records by specifying their accession number, like so:

#Parse a GenBank file into a Python dictionary

from Bio import SeqIO
handle = open("ls_orchid.gbk")
orchid_dict = SeqIO.to_dict(SeqIO.parse(handle, "genbank"))
handle.close()

Index a GenBank record by protein ID 

This useful function is from Peter Cock’s section on BioPython.

def index_genbank_features(gb_record, feature_type, qualifier) :
    answer = dict()
    for (index, feature) in enumerate(gb_record.features):
        if feature.type==feature_type:
            if qualifier in feature.qualifiers:
                for value in feature.qualifiers[qualifier]:
                    if value in answer:
                        print "WARNING - Duplicate key %s \
                                 for %s features %i and %i" % (value,\
                                 feature_type)
                    else:
                        answer[value] = index
    return answer

It’s used like this:

GBindex = index_genbank_features(gb_record,"CDS","protein_id")
print GBindex['AP0001']

If GBindex['AP0001'] is 19, then gb_record[19] is the corresponding record for that protein id. Tie it all together to get the sequence of the protein:

gb_record[GBindex['AP0001']].seq