Seq

Core Principle: The Bio.Seq.Seq class provides an immutable sequence container equipped with domain-specific biological transformations, including reverse complementation, transcription, and translation.

Creating and using

Seq supports nearly the whole str interface, so most string intuition transfers directly.

Bio.Alphabet is gone

Removed in Biopython 1.78. This is a TypeError now:

from Bio.Alphabet import IUPAC          # ImportError
Seq("ATG", IUPAC.unambiguous_dna)        # TypeError

A Seq is just letters. The library does not know whether ATG is DNA or protein, and mostly does not need to. Where a format requires it (writing GenBank), you supply it as metadata:

record.annotations["molecule_type"] = "DNA"

Every tutorial written before 2020 will show the alphabet API. See Biopython Deprecations.

The biology methods

complement() vs reverse_complement(): complement alone gives you the opposite strand read in the same direction, which is almost never biologically meaningful. For "the other strand's sequence as it would be read", you want reverse_complement().

Translation, carefully

Points to internalise:

• to_stop=True is usually what you mean. Without it, translation runs to the end of the sequence and you get MAIVMGR*KGAR* with internal stops.
• cds=True validates: it requires a length divisible by 3, a valid start codon, a single terminal stop, and no internal stops. It raises TranslationError otherwise. Use it when you believe you have a real CDS: the exception is information.
• Partial codons warn (BiopythonWarning: Partial codon) and are dropped.
• Table matters. Mitochondrial genomes use different codon tables; TGA is a stop in the standard code and tryptophan in vertebrate mitochondria. Getting this wrong silently truncates your protein.

Immutability

Immutability means Seq is hashable and safe to share. Use MutableSeq for in-place editing, then convert back.

For simulating a substitution the string route is usually clearer:

mutated = Seq(str(s)[:pos] + alt + str(s)[pos + len(ref):])

Undefined and partial sequences

This is how Biopython represents a record whose length is known from a header but whose sequence was not loaded (common with GenBank contig records and some SeqIO indexing modes). Guard with a try/except if you parse arbitrary files.

Bioinformatics examples

from Bio.Seq import Seq
from Bio.SeqUtils import gc_fraction, molecular_weight

s = Seq("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG")

gc_fraction(s)                             # 0.0–1.0 (NOT the removed GC(), 0–100)
molecular_weight(s, seq_type="DNA")
s.translate(to_stop=True)                  # MAIVMGR

# find ORFs in all six frames
def orfs(seq, min_aa=50):
    for strand, nuc in [(+1, seq), (-1, seq.reverse_complement())]:
        for frame in range(3):
            trimmed = nuc[frame: len(nuc) - (len(nuc) - frame) % 3]
            for prot in trimmed.translate().split("*"):
                if len(prot) >= min_aa:
                    yield strand, frame, prot

# reverse-strand variant: get the sequence as the transcript reads it
if strand == "-":
    coding = genomic_seq.reverse_complement()

# codon usage
codons = [str(s[i:i+3]) for i in range(0, len(s) - 2, 3)]
pd.Series(codons).value_counts()

# GC at the third codon position (GC3): a codon-bias measure
gc3 = sum(1 for i in range(2, len(s), 3) if s[i] in "GC") / (len(s) // 3)

Ambiguity codes

IUPAC ambiguity letters (N, R, Y, W, S, K, M, ...) are handled correctly by complement/reverse_complement: R (A or G) complements to Y (C or T). Translation of an ambiguous codon gives X where the amino acid is undetermined, or the specific residue where all possibilities agree.

Real-world sequences contain N (unknown base) and soft-masked lowercase (repeat-masked regions). s.upper() before comparisons, and decide deliberately whether N counts in your GC denominator: gc_fraction has an ambiguous= parameter for this.

Common mistakes

• Using Bio.Alphabet. Removed.
• ungap(), tomutable(), toseq(). Removed. Use .replace("-", "") and the constructors.
• translate() without to_stop=True, getting internal stops.
• Wrong codon table for mitochondrial or bacterial sequences.
• complement() where you meant reverse_complement().
• Forgetting reverse-strand genes need reverse-complementing before translation.
• Assuming Seq is mutable.
• Ignoring soft-masking. Lowercase bases fail a naive == "G" test.
• SeqUtils.GC(): removed in 1.82, and it returned a percentage while gc_fraction returns a fraction. Off by 100×.

See also

SeqRecord · SeqIO · Bio.SeqUtils · Biopython Deprecations · Applied - Sequence Composition Analysis · Applied - FASTA and FASTQ Workflows

Exercise

Biopython is not installed here, so build the standard codon table yourself and translate with it. The table is generated from the base order TCAG: iterate the first, second and third position in that order through all 64 combinations, and read off the amino acids in the same order from

FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG

Write translate_report(raw) returning three strings. Upper-case the input first, because soft-masked lowercase bases are common and a naive lookup would miss every one of them. Translate frame 0 only, dropping a trailing partial codon rather than padding it, and rendering any codon containing a character other than A, C, G or T as X. Return the full translation with * for stop codons, then the translation truncated before the first stop, then the same truncated translation of the reverse complement. Print them as full=, to_stop= and rc_to_stop=. Complement A to T, C to G and their inverses, and map anything else to N. A sequence shorter than three bases yields three empty values, and the three lines must still be printed.