Claudia's Next Problem

Many sequences, not one

Your translator handles one sequence. Claudia has a folder of them. She could copy-paste the loop for each — seq1, seq2, seq3… — but she wants to do them all in one go.

…and one of them is broken

Look at sequence 2 on her screen — it's full of Ns. Real sequencing data is like this. Her program didn't crash: it handed back MAANNNN…RGPNS* — something that looks like a protein and isn't.

What she needs

A plan for the whole job · her translator packaged up so it runs on any sequence · and a program that says so when the data is wrong. Look at the books on her desk — that is today.

This Session — the Books on Her Desk

You Already Wrote an Algorithm

You Already Do This at the Bench

Break Down: the Other Strand

"Give me the reverse complement of this sequence." DNA is double-stranded — genes are read off both strands. Sounds like a real piece of software. Break it down first:

Session 2 promised you'd build this one day. It took three steps:

Question 1 — One step

Which of these is one step — small enough to look up how to do?

Question 2 — The order

Which order of steps works?

Question 3 — Starts with ATG

Which test keeps only the sequences that start with ATG?

for seq in seqs:
    if ???:
        atg_seqs.append(seq)

Question 4 — GC of each one

Work out the GC content of each one — which Python shape is that?

Question 5 — Report the mean

Which line gives the mean of the ATG starters?

# gc_values holds the GC % of the ATG starters only

Revision — From Plan to Code

Chains Get Long — so package them in Functions

seq = "ATGGTACGCTGGACTTTGTGG"

# reverse complement it
complement = {"A": "T", "T": "A", "G": "C", "C": "G"}
rc = ""
for base in seq[::-1]:
    rc = rc + complement[base]

# now translate it
protein = ""
for i in range(0, len(rc) - 2, 3):
    codon = rc[i:i+3]
    protein = protein + codon_table.get(codon, "?")

print(protein)          # PQSPAYH

seq = "ATGGTACGCTGGACTTTGTGG"

rc = reverse_complement(seq)
protein = translate(rc)

print(protein)          # PQSPAYH

Packaging It Up — def

That chain did two separate things — flip the strand, then read the codons. Two things → two packages.

Same sequence, same PQSPAYH — now in two named pieces:

The Simplest Function

That last slide was where we're heading. Let's build it from nothing. Here is the smallest function that exists — it takes nothing, gives nothing back, and just prints.

Run it — then delete the two calls at the bottom and run again. Nothing happens:

Give It Something to Work On

A function that always does exactly the same thing isn't much use. Put a name inside the brackets and it can work on anything you hand it.

Run it — then add a report() call with your own sequence:

Naming Functions

Same rules as variables. The one difference: a variable holds a thing, so it gets a noun; a function performs an action, so it wants a verb.

Python doesn't care — def f(x): runs perfectly. The name is for humans, and the human who'll be most confused by f is you, in six weeks.

Hand the Answer Back — return

So far our functions only printed. That's a dead end — you can read it, but your program can't use it.

Both print a 9 — but only one of them gives you the 9: 💡 A function with no return still gives you something back:

Two Parameters — and a Default

Run it — the first call never mentions a position, and still works:

Why Bother? Readable · Reusable

Scroll past the definitions and look at the last three lines. Add a fourth sequence to the list and run again — nothing else needs touching. That is the whole point.

Say What It Does — docstrings

Run it — you never wrote a help page, but you have one:

Step 1 — Start the function

Which line starts the function?

Step 2 — The body

Which line belongs inside the function?

def gc_content(seq):
    # ???

Step 3 — Hand it back

Which last line hands the answer back?

Step 4 — The docstring

Where does the docstring go?

Step 5 — print or return?

What does this print?

def gc_content(seq):
    gc = (seq.count("G") + seq.count("C")) / len(seq) * 100
    print(round(gc, 1))

result = gc_content("GGGCGCGCGCAATATA")
print(result)

Revision — Package the Spaghetti

Real Data Is Messy

Defensive Programming — check first

One bad sequence in 1,000 shouldn't kill the run. The simplest fix is one you already own — an if. Look before you leap: only translate sequences you know are clean.

Four sequences, two with Ns — it runs to the end and reports:

Fail Loudly — raise

The Advanced Pattern — try / except

Sometimes you can't check in advance. Is "12.5" a number? The only way to know is to try converting it — and be ready if it fails.

A column of mixed values — the bad ones become None instead of a crash:

Which One? if vs try / except

Step 1 — Tidy it

Step 1 — which line tidies the input?

def clean_dna(seq):
    # ???

Step 2 — Spot bad DNA

Step 2 — which condition is True when the sequence is not clean DNA?

Step 3 — Fail loudly

Inside that if — which line fails loudly?

Step 4 — Messy and bad

What does clean_dna("atgcn") do?

def clean_dna(seq):
    seq = seq.upper().strip()
    if not all(base in "ATGC" for base in seq):
        raise ValueError(f"Not DNA: {seq}")
    return seq

Step 5 — Catch it

Calling it safely on a list — what does this print?

for s in ["atg", "AXG", "gc "]:
    try:
        print(clean_dna(s))
    except ValueError:
        print("skipped", s)

Revision — A Defensive Function

Claudia's Whole Job — One Program

The complete ORF translator — clean, translate, and run the whole folder in one go:

⏳Python editor will load when you reach this slide.

Recap — Sessions 1–4

Four sessions ago a variable was a new word. You're leaving able to write a real, defensive bioinformatics program — one that reads a whole folder, translates every gene, and refuses the data it can't trust. That's not a beginner exercise. That's programming.

You now have the basic skills to write Python Code

Every program you wrote had the same shape: a list of things → do the same job to each → handle the odd broken one. That shape has nothing to do with sequences. Point it at anything you'd otherwise do by hand.

What's Next — From Writing Code to Using It