Extract nucleic acids, run PCR and qPCR, read gels, Western blots and ELISAs, compare sequencing methods, and work with sequences and BLAST.

Molecular Biology Methods

## Why it matters

Reading DNA sequence is now routine: confirming a plasmid clone, checking a patient variant, identifying a microbe, profiling a tumour or measuring expression of every gene at once. Different jobs need different technologies, and choosing badly wastes money or misses the answer. Technicians prepare samples for sequencing and often do the first quality checks on the data, so you need to know what each method can and cannot do.

## Sanger sequencing

Sanger, or **chain-termination**, sequencing (1977) is still the standard for reading one short region with high accuracy.

1. A sequencing reaction resembles PCR with **one primer**, normal dNTPs and a small amount of fluorescently labelled **dideoxynucleotides (ddNTPs)**. A ddNTP has no 3' hydroxyl, so when the polymerase adds one, that strand stops growing.
2. The result is a mix of fragments ending at every position, each tagged with a colour for its last base.
3. **Capillary electrophoresis** separates fragments by length with single-base resolution, and a laser reads the colour of each as it passes.
4. The output is a **chromatogram** (trace) of coloured peaks, plus the base calls.

Strengths: very accurate, reads of about 700 to 1,000 bases, cheap and fast for a few samples. Limits: one template per reaction, so it does not scale to whole genomes, and it struggles to detect variants present in only a small fraction of cells (below roughly 15 to 20 percent).

Typical uses: confirming a cloned insert, checking a CRISPR edit at one site, confirming a variant found by NGS.

## Next-generation sequencing (NGS)

NGS (also called massively parallel or high-throughput sequencing) reads millions to billions of DNA fragments at once. The most widespread approach, **sequencing by synthesis** from Illumina, works like this:

1. **Library preparation:** DNA is fragmented and short **adapters** are added to both ends, often with **index** sequences (barcodes) so many samples can share one run.
2. **Cluster generation:** fragments bind to a flow cell and are copied in place into clusters of identical molecules.
3. **Sequencing:** fluorescent, reversibly terminated nucleotides are added one base per cycle and imaged, so every cluster is read in parallel.
4. The output is **short reads** (commonly 50 to 300 bases, often paired-end) in **FASTQ** files, which store each read with a quality score per base.

**Long-read** technologies (Pacific Biosciences and Oxford Nanopore) read single molecules thousands to over a hundred thousand bases long. They help with repeats, structural variants and assembling new genomes.

## Key numbers you will see

- **Phred quality (Q):** Q = -10 log10(error probability). Q20 means a 1 in 100 chance a base is wrong; **Q30** means 1 in 1,000, a common quality benchmark.
- **Coverage (depth):** how many reads cover each base on average.

```text
coverage = number of reads x read length / genome size
```

**Worked example.** 40 million reads of 150 bases on a 5 million base bacterial genome: 40,000,000 x 150 / 5,000,000 = **1,200x** coverage, far more than the roughly 30 to 100x usually wanted. You could multiplex many more samples on the same run.

## Choosing a method

| Question | Usual choice |
|---|---|
| Is my 800 bp plasmid insert correct? | Sanger |
| Which variants does this patient carry across 50 cancer genes? | Targeted NGS panel |
| Which genes changed expression after treatment? | RNA-seq (NGS) |
| What microbes are in this sample? | 16S amplicon or shotgun NGS |
| Assemble a new genome with long repeats | Long reads, often combined with short reads |

Clinical sequencing tests are validated and run under laboratory regulations and accreditation (in the US, CLIA and often CAP), and results are reviewed by qualified staff. Sample handling happens in the lab under supervision.

## Common mistakes

- Sending a mixed template (two PCR products) for Sanger and getting an unreadable trace.
- Expecting Sanger to detect a variant present in 5 percent of cells.
- Ignoring the first and last bases of a Sanger read, where quality is usually poor.
- Planning NGS without calculating the coverage you need.
- Mixing up sample indexes, which assigns reads to the wrong sample.

## Quick recap

- Sanger: ddNTP chain termination plus capillary electrophoresis; one region, very accurate, about 1 kb.
- NGS: library prep, clusters, sequencing by synthesis; millions of short reads in FASTQ.
- Long reads help with repeats and structural variants.
- Know Phred scores (Q30 = 1 in 1,000) and coverage = reads x length / genome size.

## Try it

The **Do** tab has a quiz on choosing and interpreting sequencing methods.


Compare Sanger sequencing with next-generation sequencing and choose the right one for a job.

Sanger and NGS

What Is Sanger Sequencing?

Overview of Illumina Sequencing by Synthesis Workflow | Standard SBS chemistry

## Why it matters

Sequencing produces text: long strings of A, C, G and T. Before and after every experiment you will handle sequences: checking a primer site, finding a restriction site before cloning, measuring GC content of a region that is hard to amplify, or confirming that a read contains an expected motif. Doing this by eye is slow and error-prone. A few lines of Python do it exactly, every time, and the same ideas power the big bioinformatics tools.

## Sequences are strings

In Python, a DNA sequence is just a string. Real sequences arrive messy, with lowercase letters, spaces and line breaks (for example when copied from a FASTA file), so the first step is always to **clean** them:

```python
def clean(seq):
    return "".join(seq.split()).upper()

clean("gaat tc\nGGA")   # 'GAATTCGGA'
```

`seq.split()` splits on any whitespace and `"".join(...)` glues the pieces back together.

## The FASTA format

Most sequence files and databases use FASTA: a header line starting with `>`, then sequence lines.

```text
>sample_01 partial gene region
GATATATGCATATACTT
```

Reading a FASTA file means skipping the `>` line and joining the rest.

## GC content

GC content is the percentage of bases that are G or C. It matters because G-C pairs have three hydrogen bonds and A-T pairs two, so GC-rich DNA melts at higher temperature, is harder to amplify and can form stable secondary structures.

```python
def gc_content(seq):
    s = clean(seq)
    return 100 * (s.count("G") + s.count("C")) / len(s)
```

**Worked example.** `GATATATGCATATACTT` has 17 bases: G 2, C 2. GC content = 4 / 17 x 100 = **23.5 percent**: AT-rich.

## Reverse complement

DNA is double-stranded and the two strands run in opposite directions. The other strand, read 5' to 3', is the **reverse complement**: swap A with T and G with C, then reverse.

```python
pairs = {"A": "T", "T": "A", "G": "C", "C": "G"}
"".join(pairs[b] for b in reversed("ATGCC"))   # 'GGCAT'
```

Many restriction sites are palindromes: `GAATTC` (EcoRI) is its own reverse complement, so the enzyme recognises it on both strands.

## Finding a motif

A **motif** is a short sequence of interest: a restriction site, a primer binding site, a promoter element. You often need **every** position where it occurs, including overlapping matches. Python's `str.find` and `str.count` skip overlaps, so a sliding window is safer:

```python
for i in range(len(s) - len(m) + 1):
    if s[i:i + len(m)] == m:
        positions.append(i + 1)   # biologists count from 1
```

**Worked example.** In `GATATATGCATATACTT`, the motif `ATAT` starts at positions **2, 4 and 10** (1-based). The matches at 2 and 4 overlap. `"GATATATGCATATACTT".count("ATAT")` returns only 2, which would be wrong for this task.

Notice the off-by-one detail: Python counts from 0, but sequence coordinates in biology (and in tools such as BLAST and genome browsers) count from 1. Always state which you use.

## Libraries for real work

For bigger jobs, bioinformaticians use libraries such as **Biopython**, which reads FASTA and FASTQ files, translates sequences, runs alignments and talks to NCBI. The ideas are the ones above; the library handles edge cases and file formats. Learning the plain-Python version first means you understand what the library is doing. (Biopython is not available in this site's activity runner, so the activity uses plain Python.)

Remember also to treat sequence data with the same care as any lab record: keep the original file, note where it came from, and never edit a sequence by hand without recording why.

## Common mistakes

- Forgetting to remove whitespace and line breaks, which distorts length and GC content.
- Mixing uppercase and lowercase, so `"atg" == "ATG"` is False.
- Counting non-overlapping matches when you need all of them.
- Reporting 0-based positions as if they were 1-based.
- Writing the complement but forgetting to reverse it.

## Quick recap

- Clean sequences first: remove whitespace, uppercase.
- GC content = (G + C) / length x 100.
- Reverse complement = complement each base, then reverse.
- Find motifs with a sliding window to catch overlaps, and report 1-based positions.

## Try it

Open the **Do** tab. The GC and reverse-complement functions are written; you fill in the motif check.


Use Python to clean a DNA sequence, measure GC content and find every position of a motif.

Working with sequences

Python - DNA composition | Counting ATGC I GC content | Python 5

Open https://www.ncbi.nlm.nih.gov/nuccore/NM_000518 (human HBB mRNA). Note the accession and version and the gene name.

Click FASTA to show the sequence in FASTA format. Copy the header line and the first five lines of sequence (about 300 bases).

Open https://blast.ncbi.nlm.nih.gov/Blast.cgi, choose Nucleotide BLAST (blastn) and paste your sequence. Keep the default database and run the search.

For the top five hits, write down the description, query cover, percent identity, E-value and accession.

Open the alignment for the top hit and find the coordinates of your query on the subject (Sbjct) sequence.

Change three bases in your pasted sequence (write down which), run BLAST again, and compare percent identity and E-value with the first search.

Record the program, database, date and top accession for both searches, as you would in a lab notebook.

## Why it matters

You have a sequence. What is it, and what is it similar to? BLAST (Basic Local Alignment Search Tool) answers that in seconds by comparing your sequence against public databases holding hundreds of millions of sequences. Technicians use it to confirm a PCR product or Sanger read is the gene they expected, to identify a microbe, and to check that a primer will not bind somewhere unintended. It is free, runs in a browser and needs no account.

## Sequence databases

The main public databases are run by an international collaboration: **NCBI** (US National Center for Biotechnology Information), **ENA** (European Nucleotide Archive) and **DDBJ** (DNA Data Bank of Japan), which exchange data daily. At NCBI you will meet:

- **Nucleotide** and **GenBank**: submitted DNA and RNA sequences.
- **RefSeq**: curated reference sequences. Accessions start with a prefix such as `NM_` (mRNA), `NP_` (protein) or `NC_` (chromosome or complete genome).
- **Protein**: protein sequences.
- **Gene**: summaries that link a gene's sequences, names and literature.

Each record has an **accession number** with a version, such as `NM_000518.5`. Citing the accession and version makes your work reproducible.

## The BLAST programs

| Program | Query | Database |
|---|---|---|
| blastn | nucleotide | nucleotide |
| blastp | protein | protein |
| blastx | nucleotide, translated in all six frames | protein |
| tblastn | protein | nucleotide, translated |

Use blastn to identify a DNA sequence, blastp for a protein, and blastx when you have DNA and want to know which protein it might encode.

## Reading the results

BLAST lists **hits** (database sequences) with alignments. The columns that matter:

- **Query cover:** how much of your query is included in the alignment. A 98 percent identity over 20 percent of the query is not a convincing match for the whole sequence.
- **Percent identity:** identical positions within the aligned region.
- **E-value:** how many hits this good you would expect **by chance** in a database this size. Smaller is better: 1e-50 is overwhelmingly significant; values around 1 or higher are noise. It depends on database size and query length.
- **Max score (bit score):** alignment quality on a normalised scale; higher is better and comparable across searches.
- **Accession** and **description:** what the hit is.

**Worked example.** You BLAST a 600 bp PCR product. The top hit: "Homo sapiens hemoglobin subunit beta (HBB), mRNA", query cover 100 percent, identity 99.8 percent, E-value 0.0. One mismatch over 600 bases. Your product is HBB, and the mismatch is either a sequencing error (check the chromatogram at that position) or a real variant worth following up.

A different case: top hit with query cover 35 percent, identity 92 percent, E-value 2e-20. Part of your sequence matches, the rest does not, which might mean a chimeric product, vector sequence, or a region that is not in the database.

## The graphic and alignment views

The **graphic summary** shows each hit as a bar under your query, coloured by score, so you can see at a glance whether hits cover the whole query. The **alignment** view shows your query (`Query`) above the database sequence (`Sbjct`) with `|` for identical bases and gaps as `-`, and gives the coordinates on both, 1-based.

## Good habits

- Paste sequence in FASTA format, and trim low-quality ends of Sanger reads first.
- Choose the database deliberately (for example RefSeq for curated references, or the default nucleotide collection to cast a wide net).
- Record the program, database, date and top accession(s) in your notebook: databases grow daily, so a search repeated later can give different results.
- Never upload patient-identifiable data or confidential sequences to a public server; clinical labs use approved, often local, tools.

The NCBI BLAST service and its documentation are at https://blast.ncbi.nlm.nih.gov/Blast.cgi (Checked on 2026-10-23.)

## Common mistakes

- Trusting percent identity while ignoring query cover.
- Treating an E-value of 0.5 as a match.
- Using blastn on a protein sequence.
- Forgetting that the top hit's description can be wrong or vague if it is a poorly annotated submission.
- Not recording the database and date.

## Quick recap

- NCBI, ENA and DDBJ share sequence data; RefSeq holds curated references; cite accession.version.
- Pick the program by query and database type: blastn, blastp, blastx, tblastn.
- Read query cover, percent identity and E-value together.
- Record the program, database, date and hits; keep confidential data off public servers.

## Try it

Open the **Do** tab to fetch a real reference sequence from NCBI and BLAST it.


Run a BLAST search at NCBI and read the hit table: identity, coverage, E-value and score.

BLAST and databases

How to Use BLAST for Finding and Aligning DNA or Protein Sequences

Compare Sanger and next-generation sequencing, find motifs and GC content with Python, and run and read a BLAST search.