Python Fundamentals — String Manipulation

Before you begin, take a few minutes to check what you already know and how confident you feel. You will see the same questions again at the end of the module — this helps both you and us measure what you have learned. Click an option for every question and confidence rating, then click Next to continue.

Almost every piece of data you handle in precision medicine arrives as text before it becomes anything else.

A patient ID like "P001", a gene symbol like "APOE", a line read from a CSV file, a file name like "GTEX_blood_001.fastq", a free-text clinical note — all of them are strings. Before you can analyse them, count them, or match them against a list, you usually need to do a small amount of tidying first: chop them into pieces, trim off stray spaces, decide which ones belong together, or swap one code for another.

This module covers the everyday tools Python gives you for that kind of work. We start with four string methods you will reach for constantly:

• split() — break one string into a list of pieces. A line "S001,72,M" becomes ["S001", "72", "M"].
• strip() — remove stray whitespace from both ends. " P001 " becomes "P001".
• startswith() — ask whether a string begins with a given prefix. Useful for filtering file names or codes by project.
• replace() — swap one substring for another. Turn "M" into "Male", or strip a unit suffix like "kg" off a number.

Try every snippet in the Python Scratchpad on the right. By the end of the section you will read a messy line of patient data, clean it up, and pull each field out cleanly.

In precision health and medicine, most of the data you will encounter is not a clean number in a spreadsheet. It is a patient note, a lab report, a gene identifier, a drug name, an ICD code, or a field someone typed freehand into an EHR. Before any analysis can happen, that raw text needs to be cleaned, standardised, and parsed into usable pieces.

String methods are the tools that make this possible. Whether you are extracting a dosage from a clinical note, normalising inconsistent medication names, filtering records by a diagnostic code prefix, or preparing free-text survey responses for NLP, you will reach for split, strip, startswith, and replace constantly. They are not glamorous, but they are the unglamorous work that sits between messy real-world health data and every model, dashboard, or insight you want to build.

Here is a quick run through of the common methods:

The first method on our list is split. Imagine you read a single line out of a CSV file and the whole line lands in your code as one long string: "S001,72,M". That string is not very useful while it is still in one piece — you wanted three separate fields, not one. split takes the string apart for you. You hand it the character to split on (the comma), and it gives you back a list of pieces.

The shape is some_string.split(separator). The separator goes inside the brackets as a string itself; that is why the comma has quotes around it. The result is a list, so everything you already know about lists applies — parts[0] gives you "S001", parts[1] gives you "72", and len(parts) tells you how many fields there are.

line = "S001,72,M"
parts = line.split(",")
print(parts)

One thing worth keeping in mind: split returns a list of strings, even if the pieces look like numbers. After splitting "S001,72,M" on a comma, the middle piece is the string "72", not the integer 72. To do arithmetic with it you have to convert it with int() or float().

Forgetting this is one of the most common errors in early data-loading code.

record = "S001,72,M"
parts = record.split(",")
age = parts[1]
years_to_60 = 60 - age
print(years_to_60)

Now, let’s try it out.

line = "S001,72,M"
pid, age_str, sex = line.split(",")

age = int(age_str)
print(pid, age + 1, sex)

Now to strip. Text from the real world rarely arrives clean. A line you read from a file usually carries a hidden newline character at the end. A field copy-pasted out of a spreadsheet often has a stray space at the front. A patient ID typed by hand might be " P001 " with padding on both sides.

You can spend hours chasing bugs because a comparison that looks right ("P001" == "P001 ") quietly returns False over a single trailing space. strip is the cure: it returns a new copy of the string with whitespace removed from both ends.

The shape is some_string.strip(). With no argument it removes any whitespace — spaces, tabs, newlines — from both ends. The middle of the string is left alone. We use repr() in the snippet above so you can see the quotes around the cleaned string and confirm nothing is hiding at the edges; print on its own would not show trailing spaces.

Try and debug the following and see how much time you spent!

records = [" P001", "P002 ", "  P003  "]
genotypes = {"P001": "AA", "P002": "AG", "P003": "GG"}
for record in records:
    print(genotypes[record])

Now let’s try the same example with strip

records = [" P001", "P002 ", "  P003  "]
genotypes = {"P001": "AA", "P002": "AG", "P003": "GG"}
for record in records:
    print(genotypes[record.strip()])

There are a few variations to strip

(a) Custom Character Stripping: Remove specific characters instead of whitespace, pass them as an argument (e.g., some_string.strip("#") removes both leading and trailing # characters).

Note: The argument you provide is treated as a set of individual characters to remove, not an exact phrase. Using strip("abc") will remove any a, b, or c from the ends in any order. It only stops stripping when it encounters a character that is not in that provided set.

header = "###Gene: BRCA1###"
print(header.strip("#"))
brackets = "[[APOE]]"
print(brackets.strip("[]"))
flanked = "ATATCGATCGATAT"
print(flanked.strip("AT"))

(b) Targeted Stripping: Use lstrip() to remove characters only from the left side (leading). Use rstrip() to remove characters only from the right side (trailing).

raw = " P001 "
print("[" + raw.lstrip() + "]")
print("[" + raw.rstrip() + "]")

A subtle but important point: strip does not change the original string. Strings in Python cannot be modified once they exist — they are immutable. Every string method returns a new string and leaves the original alone. So clean = raw.strip() works, but writing raw.strip() on a line by itself does nothing useful, because you threw the result away. This is a frequent source of "why did my code not do anything?" confusion.

name = "  Mary  "
name.strip()
print(name)

startswith answers a yes-or-no question: does this string begin with this prefix?

You will use it any time you need to filter, categorise, or route data based on the first few characters. File names that begin with "GTEX_" come from one project; those that begin with "TCGA_" come from another. SNP IDs that start with "rs" are from one reference database; those that start with "ss" are from a different one. With startswith you can write exactly that test in one short line.

The shape is some_string.startswith(prefix). The result is True or False, which is exactly what an if statement needs. There is also a matching endswith for the other end — handy for picking out files by extension, like fname.endswith(".fastq").

fname = "GTEX_blood_001.fastq"
if fname.startswith("GTEX_"):
    print("from GTEX project")

If you have several prefixes you want to match, you do not need a long chain of or. Pass a tuple of prefixes inside the brackets and startswith returns True if the string begins with any of them.

code = "rs12345"
print(code.startswith(("rs", "ss"))) | True

Tuples are written with round brackets. The double brackets in code.startswith(("rs", "ss")) are not a typo: the outer pair belongs to the method call, and the inner pair makes the tuple. If you forget the inner pair and write startswith("rs", "ss"), Python will think you meant the second argument (a start position) and complain.

The last method in this section is replace. Whenever you need to tidy or standardise text — turn every "M" into "Male", strip the unit "kg" off a weight, swap commas for tabs in a line — replace is the tool. It scans the string for every occurrence of the old substring and gives you back a new string with each occurrence swapped for the new one.

The shape is some_string.replace(old, new). The original string is left alone — replace returns a new string, so you almost always want to assign the result back to the same variable, the way the snippet above does. Forgetting that step is the same trap we hit with strip: the work is done, but the result is thrown away, and the original variable still holds the old value.

sex = "M"
sex = sex.replace("M", "Male")
print(sex)

A subtle point: replace swaps every occurrence by default. If a string contains the old substring three times, all three get swapped. Sometimes that is what you want, sometimes not. If you only want to replace the first one or two occurrences, pass a third argument: some_string.replace(old, new, count). And remember, replace works on substrings — you can replace any string, not just single characters. "none reported".replace("none", "missing") works fine.

raw = "AAA-AAA-AAA"
raw.replace("A", "T")
raw.replace("A", "T", 2)

note = "none reported"
note.replace("none", "missing")

split takes one string and turns it into a list of pieces. join does the opposite - it takes a list of strings and glues them back into one.

The syntax looks backwards the first time you see it. The separator goes first, then .join is called on it, and the list of pieces is passed in: "".join(["S001", "72", "M"]) gives back "S00172M". Whenever you build a CSV row, a log line, or a path from parts, join is the right call.

parts = ["S001", "72", "M"]
line = "".join(parts)
print(line)

genes = ["APOE", "TREM2", "BIN1"]
print(" | ".join(genes))

ages = [54, 61, 47]
print(",".join(str(a) for a in ages))

In real code these four methods almost always show up together. A typical pattern looks like this: take a messy line, strip the padding off the whole thing, split it into fields, strip each field individually (because the padding came back on the inside after splitting), and standardise any codes with replace. The worked example below ties all four methods into one short routine.

Try and familiarize yourself with the syntax:

And now let’s try an example.

line = "  P001 ,  72 , M  "
line = line.strip()
parts = line.split(",")
patient_id = parts[0].strip()
age = parts[1].strip()
sex = parts[2].strip().replace("M", "Male").replace("F", "Female")
print(patient_id, age, sex)

You have reached the end of the module. Try the same questions again — your answers here, paired with your pre-test answers, are how we measure what the module taught you. Answer every question and confidence rating, then click Submit and see results to view your score.

Here is how your post-test answers compare with your pre-test answers. The pre/post pairing is the most reliable way to see what this module actually taught you.