Fragment Analysis
Get Fragment Sizes
from Bio import SeqIO
from Bio.Restriction import EcoRI
record = SeqIO.read('sequence.fasta', 'fasta')
seq = record.seq
# catalyze() returns tuple: (fragments_5prime, fragments_3prime)
# For standard use, take the first element
fragments = EcoRI.catalyze(seq)[0]
# fragments is tuple of Seq objects
sizes = [len(f) for f in fragments]
print(f'Fragment sizes: {sorted(sizes, reverse=True)}')
Linear vs Circular Digestion
from Bio.Restriction import EcoRI
# Linear DNA
fragments_linear = EcoRI.catalyze(seq, linear=True)[0]
# Circular DNA (plasmid)
fragments_circular = EcoRI.catalyze(seq, linear=False)[0]
# Circular produces one fewer fragment (ends join)
print(f'Linear: {len(fragments_linear)} fragments')
print(f'Circular: {len(fragments_circular)} fragments')
Get Fragment Sequences
from Bio.Restriction import EcoRI
fragments = EcoRI.catalyze(seq)[0]
for i, frag in enumerate(fragments, 1):
print(f'Fragment {i}: {len(frag)} bp')
print(f' 5' end: {frag[:20]}...')
print(f' 3' end: ...{frag[-20:]}')
Double Digest
from Bio.Restriction import EcoRI, BamHI, RestrictionBatch
# Method 1: Sequential digestion
frags_ecori = EcoRI.catalyze(seq)[0]
final_fragments = []
for frag in frags_ecori:
sub_frags = BamHI.catalyze(frag)[0]
final_fragments.extend(sub_frags)
# Method 2: Using RestrictionBatch
batch = RestrictionBatch([EcoRI, BamHI])
# Note: RestrictionBatch doesn't have catalyze, use Analysis
# Method 3: Manual calculation from positions
ecori_sites = EcoRI.search(seq)
bamhi_sites = BamHI.search(seq)
all_sites = sorted(set(ecori_sites + bamhi_sites))
fragment_sizes = []
for i in range(len(all_sites) - 1):
fragment_sizes.append(all_sites[i + 1] - all_sites[i])
# Add terminal fragments
fragment_sizes.insert(0, all_sites[0])
fragment_sizes.append(len(seq) - all_sites[-1])
Calculate Fragment Sizes from Positions
def fragments_from_positions(seq_len, cut_positions, linear=True):
'''Calculate fragment sizes from cut positions'''
if not cut_positions:
return [seq_len]
positions = sorted(cut_positions)
fragments = []
if linear:
# First fragment: start to first cut
fragments.append(positions[0])
# Middle fragments
for i in range(len(positions) - 1):
fragments.append(positions[i + 1] - positions[i])
# Last fragment: last cut to end
fragments.append(seq_len - positions[-1])
else:
# Circular: all fragments between cuts
for i in range(len(positions) - 1):
fragments.append(positions[i + 1] - positions[i])
# Wrap-around fragment
fragments.append((seq_len - positions[-1]) + positions[0])
return fragments
# Usage
sites = EcoRI.search(seq)
sizes = fragments_from_positions(len(seq), sites, linear=True)
print(f'Fragment sizes: {sorted(sizes, reverse=True)}')
Simulate Gel Pattern
def simulate_gel(fragment_sizes, ladder=None):
'''Print a text-based gel simulation'''
if ladder is None:
ladder = [10000, 8000, 6000, 5000, 4000, 3000, 2000, 1500, 1000, 750, 500, 250]
max_size = max(max(fragment_sizes), max(ladder))
print('Ladder | Digest')
print('-' * 30)
for size in sorted(ladder + fragment_sizes, reverse=True):
ladder_mark = f'{size:>6}' if size in ladder else ' '
digest_mark = '====' if size in fragment_sizes else ''
print(f'{ladder_mark} | {digest_mark}')
# Usage
sizes = [len(f) for f in EcoRI.catalyze(seq)[0]]
simulate_gel(sizes)
Detailed Fragment Report
from Bio.Restriction import EcoRI, BamHI
def fragment_report(seq, enzyme, linear=True):
'''Generate detailed fragment analysis'''
sites = enzyme.search(seq, linear=linear)
fragments = enzyme.catalyze(seq, linear=linear)[0]
print(f'Enzyme: {enzyme}')
print(f'Recognition site: {enzyme.site}')
print(f'Number of sites: {len(sites)}')
print(f'Cut positions: {sites}')
print(f'\nFragments ({len(fragments)}):')
sizes = sorted([len(f) for f in fragments], reverse=True)
total = sum(sizes)
for i, size in enumerate(sizes, 1):
pct = (size / total) * 100
print(f' {i}. {size:6d} bp ({pct:5.1f}%)')
print(f'\nTotal: {total} bp')
return sizes
# Usage
sizes = fragment_report(seq, EcoRI)
Compare Expected vs Observed Fragments
def compare_fragments(expected, observed, tolerance=50):
'''Compare expected fragment sizes with observed (from gel)'''
matched = []
unmatched_exp = list(expected)
unmatched_obs = list(observed)
for exp in expected:
for obs in observed:
if abs(exp - obs) <= tolerance:
matched.append((exp, obs))
if exp in unmatched_exp:
unmatched_exp.remove(exp)
if obs in unmatched_obs:
unmatched_obs.remove(obs)
break
print('Matched fragments:')
for exp, obs in matched:
print(f' Expected: {exp}, Observed: {obs}')
if unmatched_exp:
print(f'\nMissing (expected but not observed): {unmatched_exp}')
if unmatched_obs:
print(f'\nExtra (observed but not expected): {unmatched_obs}')
# Usage
expected = [3000, 2000, 1500, 500]
observed = [3050, 2000, 1480, 510, 200] # From gel
compare_fragments(expected, observed)
Fragment with Sequence Context
from Bio.Restriction import EcoRI
def annotated_fragments(seq, enzyme, context=50):
'''Get fragments with surrounding sequence context'''
sites = enzyme.search(seq)
fragments = enzyme.catalyze(seq)[0]
print(f'{enzyme} digest ({len(fragments)} fragments):')
for i, (frag, site) in enumerate(zip(fragments, [0] + sites), 1):
print(f'\nFragment {i}: {len(frag)} bp (starts at {site})')
print(f" 5' sequence: {str(frag[:context])}...")
print(f" 3' sequence: ...{str(frag[-context:])}")
# Usage
annotated_fragments(seq, EcoRI)
Notes
- catalyze() returns tuple - use
[0] to get 5' fragments
- Fragment order - fragments returned in 5' to 3' order
- Circular DNA - produces n fragments from n cuts (not n+1)
- Double digest - combine cut positions, then calculate fragments
Related Skills
- restriction-sites - Find cut positions for fragment calculation
- restriction-mapping - Visualize fragment positions
- enzyme-selection - Choose enzymes for desired fragments
FridrichMethod