Version Compatibility

Reference examples tested with: BioPython 1.83+

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

• Python: pip show <package> then help(module.function) to check signatures

If code throws ImportError, AttributeError, or TypeError, introspect the installed package and adapt the example to match the actual API rather than retrying.

Enzyme Selection

"Find enzymes that cut my sequence once" → Search restriction enzyme databases by cut frequency, overhang type, commercial availability, or compatible ends for cloning.

• Python: Bio.Restriction.Analysis(rb, seq) with RestrictionBatch filters

Find Enzymes by Cut Frequency

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

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

analysis = Analysis(CommOnly, seq)

# Enzymes that cut exactly once (good for linearization)
once_cutters = analysis.once_cutters()

# Enzymes that cut exactly twice (good for excision)
twice_cutters = analysis.twice_cutters()

# Enzymes that don't cut (good for cloning insert)
non_cutters = analysis.only_dont_cut()

# All enzymes that cut (any number of times)
all_cutters = analysis.only_cut()

Find Non-Cutters for Insert

from Bio.Restriction import Analysis, CommOnly

# Find enzymes that don't cut your insert
insert_seq = record.seq
analysis = Analysis(CommOnly, insert_seq)

non_cutters = analysis.only_dont_cut()
print('Enzymes that do not cut the insert:')
for enzyme in non_cutters:
    print(f'  {enzyme}')

Find Compatible Enzyme Pairs

from Bio.Restriction import EcoRI, BamHI, BglII, XhoI, SalI

# Check if enzymes produce compatible overhangs
def find_compatible_enzymes(enzyme):
    '''Find enzymes with same overhang'''
    compatible = enzyme.compatible_end()
    print(f'{enzyme} is compatible with: {compatible}')

find_compatible_enzymes(BamHI)  # Compatible with BglII
find_compatible_enzymes(XhoI)   # Compatible with SalI

Filter by Overhang Type

from Bio.Restriction import CommOnly, Analysis

analysis = Analysis(CommOnly, seq)
cutters = analysis.only_cut()

# Filter by overhang type
blunt_cutters = [e for e in cutters if e.is_blunt()]
five_prime = [e for e in cutters if e.is_5overhang()]
three_prime = [e for e in cutters if e.is_3overhang()]

print(f'Blunt cutters: {len(blunt_cutters)}')
print(f'5\' overhang: {len(five_prime)}')
print(f'3\' overhang: {len(three_prime)}')

Filter by Recognition Site Length

from Bio.Restriction import AllEnzymes, CommOnly

# 6-cutters (most common for cloning)
six_cutters = [e for e in CommOnly if len(e.site) == 6]

# 8-cutters (rare cutters, good for large constructs)
eight_cutters = [e for e in CommOnly if len(e.site) == 8]

# 4-cutters (frequent cutters)
four_cutters = [e for e in CommOnly if len(e.site) == 4]

print(f'4-cutters: {len(four_cutters)}')
print(f'6-cutters: {len(six_cutters)}')
print(f'8-cutters: {len(eight_cutters)}')

Find Enzymes with Specific Overhang

from Bio.Restriction import CommOnly

def find_by_overhang(overhang_seq):
    '''Find enzymes that produce a specific overhang'''
    matching = []
    for enzyme in CommOnly:
        if hasattr(enzyme, 'ovhgseq') and enzyme.ovhgseq == overhang_seq:
            matching.append(enzyme)
    return matching

# Find enzymes with AATT overhang (like EcoRI)
aatt_enzymes = find_by_overhang('AATT')
print(f'Enzymes with AATT overhang: {aatt_enzymes}')

Find Unique Cutters in Multiple Sequences

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

records = list(SeqIO.parse('sequences.fasta', 'fasta'))

# Find enzymes that cut once in each sequence
common_once_cutters = None

for record in records:
    analysis = Analysis(CommOnly, record.seq)
    once = set(analysis.once_cutters().keys())

    if common_once_cutters is None:
        common_once_cutters = once
    else:
        common_once_cutters &= once

print('Enzymes that cut once in all sequences:')
for enzyme in common_once_cutters:
    print(f'  {enzyme}')

Select Enzymes for Directional Cloning

from Bio.Restriction import Analysis, CommOnly

def find_cloning_pairs(vector_seq, insert_seq):
    '''Find enzyme pairs for directional cloning'''

    # Analyze both sequences
    vec_analysis = Analysis(CommOnly, vector_seq)
    ins_analysis = Analysis(CommOnly, insert_seq)

    # Enzymes that cut vector once
    vec_once = set(vec_analysis.once_cutters().keys())

    # Enzymes that don't cut insert
    ins_non = set(ins_analysis.only_dont_cut())

    # Candidates: cut vector once, don't cut insert
    candidates = vec_once & ins_non

    # Group by overhang type for pairs
    five_prime = [e for e in candidates if e.is_5overhang()]
    three_prime = [e for e in candidates if e.is_3overhang()]
    blunt = [e for e in candidates if e.is_blunt()]

    print(f'Candidate enzymes: {len(candidates)}')
    print(f"  5' overhang: {[str(e) for e in five_prime[:5]]}")
    print(f"  3' overhang: {[str(e) for e in three_prime[:5]]}")
    print(f"  Blunt: {[str(e) for e in blunt[:5]]}")

    return candidates

# Usage
# candidates = find_cloning_pairs(vector_seq, insert_seq)

Check Commercial Availability

from Bio.Restriction import CommOnly, AllEnzymes, EcoRI

# Check if enzyme is commercially available
def is_commercial(enzyme):
    return enzyme in CommOnly

print(f'EcoRI commercial: {is_commercial(EcoRI)}')

# List all commercial enzymes
print(f'Total commercial enzymes: {len(CommOnly)}')

Find Isoschizomers

from Bio.Restriction import EcoRI, HpaII

# Isoschizomers: same recognition, may have different cuts
isoschizomers = EcoRI.isoschizomers()
print(f'EcoRI isoschizomers: {isoschizomers}')

# Neoschizomers: same recognition, different cut position
neoschizomers = HpaII.neoschizomers()
print(f'HpaII neoschizomers: {neoschizomers}')

Check Methylation Sensitivity

Some enzymes are blocked by DNA methylation (Dam, Dcm in E. coli). Important when digesting genomic DNA from bacteria.

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

# Check if enzyme is sensitive to methylation
def check_methylation(enzyme):
    dam = enzyme.is_dam_methylable()
    dcm = enzyme.is_dcm_methylable()
    print(f'{enzyme}: Dam={dam}, Dcm={dcm}')

check_methylation(DpnI)   # Requires Dam methylation to cut
check_methylation(DpnII)  # Blocked by Dam methylation
check_methylation(Sau3AI) # Not affected by Dam
check_methylation(MboI)   # Blocked by Dam methylation

from Bio.Restriction import CommOnly, Analysis

# Find enzymes not affected by common methylation
def find_methylation_insensitive(seq):
    analysis = Analysis(CommOnly, seq)
    cutters = analysis.only_cut()

    insensitive = [e for e in cutters
                   if not e.is_dam_methylable() and not e.is_dcm_methylable()]

    print(f'Methylation-insensitive cutters: {len(insensitive)}')
    return insensitive

# Usage for genomic DNA from E. coli
# insensitive = find_methylation_insensitive(seq)

Type IIS Enzymes for Golden Gate Cloning

Type IIS enzymes cut outside their recognition site, enabling scarless assembly.

from Bio.Restriction import BsaI, BbsI, BsmBI, SapI

# Type IIS enzymes cut outside recognition sequence
# BsaI: GGTCTC(N)1 - cuts 1bp after recognition
# BsmBI: CGTCTC(N)1

def type_iis_info(enzyme):
    print(f'{enzyme}:')
    print(f'  Recognition: {enzyme.site}')
    print(f'  Overhang: {enzyme.ovhg} bp ({enzyme.ovhgseq if enzyme.ovhgseq else "variable"})')
    print(f'  Cuts outside: {enzyme.fst3cut}, {enzyme.fst5cut}')

type_iis_info(BsaI)
type_iis_info(BsmBI)

from Bio.Restriction import BsaI, BsmBI
from Bio.Seq import Seq

# Golden Gate assembly: design parts with compatible overhangs
# BsaI creates 4-bp overhangs that can be designed for specific fusion

def find_golden_gate_sites(seq, enzyme=BsaI):
    '''Find Type IIS sites and their overhang positions'''
    sites = enzyme.search(seq)

    if not sites:
        print(f'No {enzyme} sites found - sequence is Golden Gate compatible')
        return []

    print(f'{enzyme} sites found at: {sites}')
    print('These sites must be removed for Golden Gate cloning')
    return sites

# Check if insert is free of BsaI sites
insert_seq = Seq('ATGCGATCGATCGATCG')
find_golden_gate_sites(insert_seq, BsaI)

# Common Type IIS enzymes for Golden Gate/modular cloning
from Bio.Restriction import BsaI, BsmBI, BbsI, SapI, BtgZI

golden_gate_enzymes = [BsaI, BsmBI, BbsI, SapI, BtgZI]

for enzyme in golden_gate_enzymes:
    print(f'{enzyme}: site={enzyme.site}, overhang={enzyme.ovhg}bp')

Enzyme Properties Reference

from Bio.Restriction import EcoRI

# Get all properties
print(f'Site: {EcoRI.site}')
print(f'Cut: {EcoRI.fst3cut}, {EcoRI.fst5cut}')
print(f'Overhang: {EcoRI.ovhg} ({EcoRI.ovhgseq})')
print(f'Blunt: {EcoRI.is_blunt()}')
print(f'5\' overhang: {EcoRI.is_5overhang()}')
print(f'3\' overhang: {EcoRI.is_3overhang()}')
print(f'Ambiguous: {EcoRI.is_ambiguous()}')
print(f'Defined: {EcoRI.is_defined()}')

Related Skills

• restriction-sites - Find where selected enzymes cut
• restriction-mapping - Map selected enzyme sites
• fragment-analysis - Predict fragments from selected enzymes