DNA sequences as strings in Python

A DNA sequence is a long string made of four letters: A, C, G and T. Each letter names one base, a building block of DNA.

Bioinformatics uses code to count, compare and search these strings, because a computer reads millions of letters in seconds. Every sequence in this module is invented, so you can practise freely.

A DNA sequence is written as a string such as ATGGCGCATTAGCC. Each letter is a base.

Because it is a string, your string tools work on it. len gives the length and a for loop visits each base. count says how many times one base appears.

# An invented sequence of 14 bases.
seq = "ATGGCGCATTAGCC"
for base in "ACGT":
    print(base, seq.count(base))
gc = seq.count("G") + seq.count("C")
print("GC content:", round(100 * gc / len(seq), 1), "percent")
# Change seq to "GGCCGGCC" and run again. Work out the answer first.

GC content is the number of G and C bases divided by the length, times 100. For our sequence it is 8 out of 14, which is 57.1 percent.

Different stretches of DNA have different GC content, so this single number is a quick way to compare them. Always divide by the full length, never by the number of A and T.

docker exec jupyter python3 -c "s = 'ATGGCGCATTAGCC'; print(s.count('G') + s.count('C'))"

The command counts the G bases, counts the C bases and adds them. It prints 8, which is the top of the fraction 8 out of 14.

The docker exec jupyter part runs Python inside the lab, where the terminal has no Python of its own.

DNA has two strands. Each base pairs with a partner: A with T, and C with G. The complement swaps every base for its partner.

The other strand runs the opposite way, so you also read it backwards. The result is the reverse complement. For ATGC, the complement is TACG and the reverse complement is GCAT.

# The reverse complement: swap each base, then read backwards.
pairs = {"A": "T", "T": "A", "C": "G", "G": "C"}
seq = "ATGC"
complement = ""
for base in seq:
    complement = complement + pairs[base]
reverse = ""
for base in complement:
    reverse = base + reverse
print(complement)
print(reverse)
# Change seq to "GATTACA". Predict both lines before you run.

docker exec jupyter python3 -c "print(''.join({'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}[b] for b in 'GATTACA'[::-1]))"

The slice [::-1] reads GATTACA backwards. The dictionary swaps each base for its partner. The command prints TGTAATC.

This is the same job as the loop above, written on one line.