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

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