Python Fundamentals — Input and Output

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.

Real data never lives inside your script. It arrives as a TSV from a colleague, an Excel sheet from a clinic, or a list of arguments you typed at the command line. This part of the module is about pulling that data into your program and writing your results back out.

This is Part II of the Functions and Input/Output module. Part I covered functions themselves — defining them, passing arguments, scope. This part covers the two remaining tools that let your functions interact with the outside world:

• Reading and writing files — pull text or tabular data into your program, and save your results back to disk.
• Command-line arguments with sys.argv — let a script accept its inputs from the terminal so you do not have to edit the file every time you want to run it on a different dataset.

Try every snippet in the Python Scratchpad on the right. By the end of this part you will write a short script that takes a filename and a threshold from the command line, reads the file line by line, applies a function from Part I, and writes the result to a new file.

Real data does not arrive as a list typed into your script. It arrives as a TSV of patient records, a CSV of p-values, a plain text file of gene symbols. Your script needs to open the file, read its contents, do something with them, and often write a result back out. Python's built-in open() function is the door to all of that.

The simplest read pattern looks like this. The with line opens the file and gives it a short name (f) you can use inside the indented block. As soon as the block ends, Python closes the file for you — even if your code crashes partway through.

Try the code below:

Note: The “samples.txt” has been pre-loaded in the Python Scratchpad for you.

with open("samples.txt") as f:
    contents = f.read()
print(contents)

f.read() pulls the whole file into a single string. That is fine for small files but a bad idea for a 50 GB file. The more common pattern is to walk the file line by line — open() gives you an iterable, so a for loop just works.

with open("samples.txt") as f:
    for line in f:
        print(line.strip())

Something that is important for you to remember.

First, each line you get from the loop ends with a newline character. If you print it directly, you get blank lines between the entries because print adds its own newline on top. .strip() removes leading and trailing whitespace — including the newline — and is almost always what you want.

Compare and contrast the following codes. Try it yourself!

(a) with print(line)

with open("patients.tsv") as f:
 for line in f:
 print(line)

(b) with print(line.strip())

with open("patients.tsv") as f:
 for line in f:
 print(line.strip())

Second, if your file is tab-separated, you split each line into columns with line.split("\t"). That gives you a list of strings; remember that everything is a string until you convert it.

To write to a file, pass a second argument to open() specifying your mode: "w" to write (which overwrites existing content) or "a" to append (which adds to the end).

Inside your file-handling block, you have two main ways to write text:

print(value, file=f): This is the simplest approach. It works exactly like a standard print statement, but directs output to the file and automatically adds a newline.

f.write(text): This lower-level method writes exactly the string you pass it without adding a newline.

While f.write() is the right tool when you need precise control, print() is often cleaner and less error-prone for everyday output.

results = [("P001", 22.4), ("P002", 27.8), ("P003", 31.5)]
with open("bmi_results.tsv", "w") as f:
    print("patient_id\tbmi", file=f)
    for pid, bmi in results:
        print(f"{pid}\t{bmi:.1f}", file=f)

So far, every value your script depends on is hard-coded in the file. The filename you read from, the threshold you filter on, the patient ID you are interested in — all written into the .py and changed by editing the .py. That works once. The second time you run the same analysis on a different file you start to mind.

The standard fix is to let the script accept its inputs from the command line when you run it, which is what sys.argv is for.

The sys module is part of Python's standard library, so you do not install anything — you just add import sys at the top of your script. The list sys.argv holds the command-line arguments.

A few important points about sys.argv:

• The first entry, sys.argv[0], is the name of the script itself.
• Anything after that is a value the user typed on the command line, in order.
• Every entry in sys.argv arrives as a string, even if the user typed a number. If you need a number as argument, convert it with int() or float() before using it

Actually running a script like this needs a few things — Python installed locally, a working terminal, and a .py file saved to your computer — which is beyond the scope of this tutorial.

For now you only need to recognise sys.argv when you see it in real code and understand that it is how a script picks up values typed at the command line.

The terminal setup is something you can pick up later, when you start writing analysis scripts you run yourself.

The two tools in this part are almost always used together, and they combine with the functions from Part I to make a full reusable command-line tool. A typical short script takes a filename and a threshold from the command line, opens the file with with open() as f, walks each line, applies a function from Part I to decide whether to keep or transform it, and writes the kept rows to a new output file.

sample = """uniprot_id\tabundance
P12345\t152.4
Q9Y6K1\t42.7
P38398\t201.5
"""
with open("proteins.tsv", "w") as f:
    f.write(sample)

with open("proteins.tsv") as fin, open("abundant.tsv", "w") as fout:
    fout.write(next(fin))
    for line in fin:
        parts = line.strip().split("\t")
        abundance = float(parts[1])
        if abundance > 100.0:
            fout.write(line)

with open("abundant.tsv") as f:
    print(f.read())

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.