Bio Restriction Enzyme Selection

Version Compatibility

Reference examples tested with: BioPython 1.83+ (API verified on 1.86)

Before using code patterns, verify installed versions match. If versions differ:

• Python: pip show biopython then help(Bio.Restriction.Analysis) to confirm method names

If code throws ImportError, AttributeError, or TypeError, introspect the installed package and adapt the example to match the actual API rather than retrying. The Analysis cut-count methods were renamed across versions (see Common Errors).

Restriction Enzyme Selection

"Pick enzymes to clone my insert into this vector" -> Search the enzyme database under the constraints that actually matter: cuts the vector once, leaves the insert intact, makes a usable end, is buyable, and is not silenced by methylation.

• Python: Bio.Restriction.Analysis(CommOnly, seq) with with_N_sites/without_site, plus enzyme predicates for overhang and compatibility.

The canonical selection is an intersection, not a single query: an enzyme that cuts the vector exactly once at the cloning site AND does not cut the insert AND leaves the intended overhang AND is commercially available AND is not blocked by the methylation on the source DNA. Each constraint below is one filter in that intersection; the skill's value is composing them, not running any one alone.

The Selection Decision Table

Naive cut-frequency intuition (a 6-cutter every 4^6 = 4096 bp) fails on real genomes: vertebrate CpG suppression makes any CpG-containing site -- NotI GCGGCCGC above all -- far rarer than 1/4^n, which is exactly why NotI and other 8-cutters are the rare-cutters of choice for large mammalian fragments.

Find Enzymes By Cut Frequency

Goal: Sort candidates into single-cutters (linearize), double-cutters (excise), and non-cutters (safe through the digest).

Approach: Analysis exposes with_N_sites(n) for an exact cut count and without_site() for non-cutters. (The older once_cutters() / twice_cutters() / only_dont_cut() / only_cut() names do not exist in current BioPython and raise AttributeError.)

from Bio import SeqIO
from Bio.Restriction import Analysis, CommOnly

record = SeqIO.read('sequence.fasta', 'fasta')
analysis = Analysis(CommOnly, record.seq)

single_cutters = analysis.with_N_sites(1)   # linearization candidates
double_cutters = analysis.with_N_sites(2)   # excise-an-insert candidates
non_cutters    = analysis.without_site()    # safe to keep in a multi-enzyme digest
all_cutters    = analysis.with_sites()      # any number of sites
print(f'{len(single_cutters)} single-cutters, {len(non_cutters)} non-cutters')

Select A Pair For Directional Cloning

Goal: Two enzymes that each cut the vector once, neither cuts the insert, and their ends differ so the ligation is directional and the vector cannot recircularize.

Approach: Intersect "cuts vector once" with "does not cut insert", then pair candidates whose ends are mutually INCOMPATIBLE -- that is what makes the cloning directional and stops the vector self-ligating. Two enzymes are an incompatible (directional) pair when neither appears in the other's compatible_end().

from itertools import combinations
from Bio.Restriction import Analysis, CommOnly

def directional_pairs(vector_seq, insert_seq):
    vec_once  = set(Analysis(CommOnly, vector_seq, linear=False).with_N_sites(1))
    ins_clear = set(Analysis(CommOnly, insert_seq).without_site())
    candidates = sorted(vec_once & ins_clear, key=str)
    pairs = []
    for a, b in combinations(candidates, 2):
        if b not in a.compatible_end():          # incompatible ends -> directional, no self-ligation
            pairs.append((a, b))
    return pairs                                  # each pair cuts vector once, leaves insert intact

Find Compatible And Isocaudomer Ends

Goal: Identify enzymes whose overhangs ligate together, including enzymes with different recognition sites that leave the same overhang (isocaudomers).

Approach: compatible_end() returns every enzyme that can leave a compatible overhang -- including Type IIS enzymes whose overhang is user-defined, not fixed. For a real ligation partner, filter the result to fixed-overhang Type IIP enzymes (the true isocaudomers, e.g. BamHI/BglII/BclI/Sau3AI all leave 5'-GATC); a Type IIS enzyme listed here is not a drop-in cloning partner.

from Bio.Restriction import BamHI

partners = BamHI.compatible_end()                  # any enzyme that can leave a 5'-GATC end
fixed = [e for e in partners if e.is_palindromic()] # keep Type IIP isocaudomers (BglII, BclI, MboI, Sau3AI...)
print(f'BamHI isocaudomers (fixed overhang): {sorted(str(e) for e in fixed)}')

Ligating two different-but-compatible sites usually creates a hybrid junction that neither enzyme re-cleaves (BamHI G^GATCC + BglII A^GATCT -> GGATCT/AGATCC, which is neither site). This makes the join directional and is used deliberately to destroy one site -- but whether the junction is recut is pair-dependent, so verify the specific pair rather than assuming.

Filter By Overhang And Recognition Length

from Bio.Restriction import CommOnly, Analysis

cutters = Analysis(CommOnly, record.seq).with_sites()

blunt   = [e for e in cutters if e.is_blunt()]
five_p  = [e for e in cutters if e.is_5overhang()]
three_p = [e for e in cutters if e.is_3overhang()]

six_cutters   = [e for e in CommOnly if len(e.site) == 6]   # routine cloning
eight_cutters = [e for e in CommOnly if len(e.site) == 8]   # rare cutters

Methylation Sensitivity (The Silent-Failure Trap)

Standard E. coli cloning strains (DH5-alpha, JM109, TOP10) are dam+ dcm+, so plasmid and insert DNA prepped from them is methylated at GATC (Dam, N6-methyladenine) and CCWGG (Dcm, 5-methylcytosine). An enzyme blocked by that mark will fail or partially cut even though the recognition site is present -- a silent failure. Mammalian genomic DNA additionally carries CpG (5mC) methylation. The fix is to re-propagate the DNA in a dam- dcm- strain (GM2163, JM110, INV110) before cutting.

Do NOT rely on BioPython's enzyme.is_methylable() to make this decision: it is a coarse REBASE flag (it returns True for Sau3AI, which is actually Dam-insensitive, and for EcoRI), does not distinguish Dam vs Dcm vs CpG, and does not indicate the direction of the effect. Use the curated cases above and consult REBASE for the specific methyltransferase that blocks a given enzyme.

from Bio.Restriction import DpnI, DpnII, Sau3AI, MboI

# Curated, not from is_methylable(): the GATC quartet a cloner must know.
dam_behavior = {
    'DpnI': 'requires Dam methylation to cut',
    'DpnII': 'blocked by Dam methylation',
    'MboI': 'blocked by Dam methylation',
    'Sau3AI': 'insensitive to Dam methylation',
}
for enz in (DpnI, DpnII, MboI, Sau3AI):
    print(f'{enz} ({enz.site}): {dam_behavior[str(enz)]}')