FridrichMethod Enzyme Selection
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)
# 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)
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