CSV Files

A CSV file (Comma Separated Values) is an ordinary text file that stores a table. Each line is one record, and inside a line the fields are separated by commas.

Roll,Name,Marks
1,Aarav Sharma,88
2,Diya Nair,92

That is the entire format. Open the file in Notepad and you see text; open the very same file in Excel or Google Sheets and you see a spreadsheet. This is why almost every system hands you data as CSV — your school's marksheet export, a bank statement download, IRCTC booking history, a UPI transaction report. CSV is the plain-text handshake between two programs that share nothing else.

Where CSV sits among the file types in this unit:

Now the question that actually matters. If a CSV is nothing but commas and newlines, why import csv at all? Why not build each line yourself with ",".join(...)?

Because of one address. Watch what happens when a field itself contains a comma.

import csv

rows = [["Aarav Sharma", "Mumbai, Maharashtra", 45000],
        ["Diya Nair", "Kochi", 38000]]

# Way 1: joining strings by hand
f = open("hand.csv", "w")
for r in rows:
    f.write(",".join(str(x) for x in r) + "\n")
f.close()

# Way 2: the csv module
f = open("safe.csv", "w", newline="")
csv.writer(f).writerows(rows)
f.close()

print("hand.csv:", repr(open("hand.csv").read()))
print("safe.csv:", repr(open("safe.csv").read()))

print("\nReading hand.csv back:")
for rec in csv.reader(open("hand.csv")):
    print(len(rec), "fields ->", rec)

print("\nReading safe.csv back:")
for rec in csv.reader(open("safe.csv", newline="")):
    print(len(rec), "fields ->", rec)

Real output:

hand.csv: 'Aarav Sharma,Mumbai, Maharashtra,45000\nDiya Nair,Kochi,38000\n'
safe.csv: 'Aarav Sharma,"Mumbai, Maharashtra",45000\nDiya Nair,Kochi,38000\n'

Reading hand.csv back:
4 fields -> ['Aarav Sharma', 'Mumbai', ' Maharashtra', '45000']
3 fields -> ['Diya Nair', 'Kochi', '38000']

Reading safe.csv back:
3 fields -> ['Aarav Sharma', 'Mumbai, Maharashtra', '45000']
3 fields -> ['Diya Nair', 'Kochi', '38000']

Look carefully at what broke. In hand.csv the address Mumbai, Maharashtra went in raw, so the comma inside the address became a separator. A record written with 3 fields came back with 4. Aarav's salary is now in field 3, where the state name should be. Every column after the damage is shifted by one — and Python raised no error at any point. That is the worst kind of bug: silent, and only discovered weeks later when someone's salary looks wrong.

The csv module saw the comma and wrapped the field in double quotes by itself: "Mumbai, Maharashtra". On the way back, reader() understood those quotes and returned 3 fields. You wrote no quoting logic at all. That is the whole reason the module exists — it already knows the escaping rules, so you never have to.

Every CSV program has the same three-step shape. First import csv. Then open the file with open(), choosing the mode: 'r' to read, 'w' to create or overwrite, 'a' to add to the end. Then close it with f.close(), or let a with block close it for you. Until the file is closed, what you wrote may still be sitting in a buffer and the file on disk can be empty.

One detail in the code above is not decoration: the newline="" in the open() call. Leave it out on Windows and every record picks up an extra carriage return, so a blank line appears between rows and csv.reader() hands you twice as many rows as you wrote. Section 3 proves it byte by byte — start typing newline="" now so it becomes a reflex.

One matching caution, so the reflex does not become superstition: newline="" belongs on the file object you are about to hand to csv.writer() or csv.reader(). When you only want to dump a file to the screen with print(open("data.csv").read()), plain open() is the right call — Section 3 shows why.

Writing a CSV takes two objects, and students routinely confuse them.

1. The file object, returned by open(). This is the connection to the disk.
2. The writer object, returned by csv.writer(fileobject). This is the thing that knows the CSV rules — commas, quotes, line endings.

The writer does not open or close anything. It only formats. You still open the file yourself and you still close it yourself. csv.writer() takes the file object as its argument, so the file must already be open in 'w' or 'a' mode before you call it.

writerow() takes one sequence — a list or a tuple — and writes it as one line of the file. Numbers are converted to text for you, so you never call str() on them.

The mode you choose decides whether yesterday's data survives. 'w' truncates the file to zero bytes the moment open() runs; 'a' positions you at the end and adds. This program shows both, plus the return value of writerow(), which is not what most students expect.

import csv

# STEP 1 - create the file with 'w'
f = open("fees.csv", "w", newline="")
wr = csv.writer(f)
n = wr.writerow(["Roll", "Name", "FeePaid"])
print("writerow() returned:", n)
wr.writerow([1, "Aarav Sharma", 12000])
wr.writerow([2, "Diya Nair", 9500])
f.close()
print("after 'w':")
print(open("fees.csv").read())

# STEP 2 - add one more with 'a'
f = open("fees.csv", "a", newline="")
csv.writer(f).writerow([3, "Kabir Menon", 15000])
f.close()
print("after 'a':")
print(open("fees.csv").read())

# STEP 3 - opening with 'w' again destroys everything
f = open("fees.csv", "w", newline="")
csv.writer(f).writerow([99, "Oops", 0])
f.close()
print("after 'w' again:")
print(open("fees.csv").read())

Real output:

writerow() returned: 19
after 'w':
Roll,Name,FeePaid
1,Aarav Sharma,12000
2,Diya Nair,9500

after 'a':
Roll,Name,FeePaid
1,Aarav Sharma,12000
2,Diya Nair,9500
3,Kabir Menon,15000

after 'w' again:
99,Oops,0

Three things to take from that output.

writerow() returned 19, not None. The documented rule is that writerow() hands back whatever the underlying file object's write() method returns, and for a text file that is the number of characters written: Roll,Name,FeePaid is 17 characters plus the two-character line ending \r\n, giving 19. You will almost never use this value, but it is a favourite one-mark trap, because the instinctive answer — None — is wrong. (writerows(), covered in Section 4, genuinely does return None; the pair makes a neat exam question.)

Mode 'a' preserved all three earlier records and added the fourth. This is the mode every "write a function to add a record" board question needs.

Mode 'w' the second time wiped the file down to a single row. Nothing warned you. If your program opens a data file with 'w' every time it runs, it destroys the previous run's data on startup — a real bug that has cost students marks and companies data.

Note also that the writer accepted a mixed list — an int roll number, a str name, an int amount — and wrote them all as text without complaint. A tuple works exactly the same as a list. What does not work the way you expect is passing a bare string: writerow("Delhi") treats the string as a sequence of five characters and writes D,e,l,h,i as five separate fields. Always wrap a single value in a list: writerow(["Delhi"]).

This is the single most-tested detail in the chapter, and the only one that produces a wrong file without producing an error. Read this section until it is automatic.

Here is the same data written twice — once with newline="" and once without — and then inspected at the byte level, by file size, and by row count.

import csv, os

data = [["Roll", "Name", "Marks"],
        [1, "Aarav", 88],
        [2, "Diya", 92]]

f = open("bad.csv", "w")                  # newline='' MISSING
csv.writer(f).writerows(data)
f.close()

f = open("good.csv", "w", newline="")     # newline='' PRESENT
csv.writer(f).writerows(data)
f.close()

print("bad.csv  bytes:", open("bad.csv", "rb").read())
print("good.csv bytes:", open("good.csv", "rb").read())
print("bad.csv  size :", os.path.getsize("bad.csv"), "bytes")
print("good.csv size :", os.path.getsize("good.csv"), "bytes")

b = list(csv.reader(open("bad.csv", newline="")))
g = list(csv.reader(open("good.csv", newline="")))
print("bad.csv  ->", len(b), "rows:", b)
print("good.csv ->", len(g), "rows:", g)

Real output, run on Windows with Python 3.13:

bad.csv  bytes: b'Roll,Name,Marks\r\r\n1,Aarav,88\r\r\n2,Diya,92\r\r\n'
good.csv bytes: b'Roll,Name,Marks\r\n1,Aarav,88\r\n2,Diya,92\r\n'
bad.csv  size : 43 bytes
good.csv size : 40 bytes
bad.csv  -> 6 rows: [['Roll', 'Name', 'Marks'], [], ['1', 'Aarav', '88'], [], ['2', 'Diya', '92'], []]
good.csv -> 3 rows: [['Roll', 'Name', 'Marks'], ['1', 'Aarav', '88'], ['2', 'Diya', '92']]

There is no room for argument here. The bad file ends every record with \r\r\n — three characters. The good file ends every record with \r\n — two. Three records, one extra byte each, and the size goes from 40 to 43. When you read it back, csv.reader() returns 6 rows instead of 3, with an empty list [] after every real record. Open the bad file in Excel and you see a blank line between every row.

Why it happens. Two separate things each add a carriage return:

1. csv.writer always ends a record with \r\n. That is what the CSV standard specifies, on every operating system.
2. A file opened in text mode on Windows translates every \n it is given into \r\n on the way to the disk.

So the writer hands over \r\n; the \r passes through untouched, and the \n is expanded into \r\n. Result: \r + \r\n = \r\r\n. Passing newline="" tells Python to perform no line-ending translation at all, so the writer's \r\n reaches the disk exactly as written.

The rule, in one line: whenever a file object is going to be handed to csv.writer() or csv.reader(), open it with newline="". On write it is mandatory; on read the Python documentation asks for it too, so that a newline stored inside a quoted field is not mangled.

The damage is done at write time and cannot be undone at read time. Here is the same broken file read both ways:

import csv
print("read WITHOUT newline='':", list(csv.reader(open("bad.csv", "r"))))
print("read WITH    newline='':", list(csv.reader(open("bad.csv", "r", newline=""))))

print("Filtering blank rows with  if row:")
f = open("bad.csv", "r", newline="")
for row in csv.reader(f):
    if row:
        print(row)
f.close()

Real output:

read WITHOUT newline='': [['Roll', 'Name', 'Marks'], [], ['1', 'Aarav', '88'], [], ['2', 'Diya', '92'], []]
read WITH    newline='': [['Roll', 'Name', 'Marks'], [], ['1', 'Aarav', '88'], [], ['2', 'Diya', '92'], []]
Filtering blank rows with  if row:
['Roll', 'Name', 'Marks']
['1', 'Aarav', '88']
['2', 'Diya', '92']

Both reads give the same six rows — adding newline="" at read time repairs nothing, because the extra bytes are physically on the disk. The only cure at read time is to skip the empties with if row:, which is worth knowing because sooner or later you will be handed a CSV that somebody else wrote badly. But in your own code, fix it at the source.

One more place the doubling shows up: your screen. Run print(open("good.csv", newline="").read()) on a perfectly good file and you still see a blank line between every row. Nothing is wrong with the file — newline="" passed the real \r\n straight through to print, and the Windows console then expanded that \n exactly the way the file did earlier. It is a display artefact only. So: use newline="" for the file object you hand to csv.reader() or csv.writer(), and a plain print(open("good.csv").read()) when you just want to look at the contents. Every display read in this chapter is written that way.

One practical consequence for exam questions: on a file written without newline="", a record count computed as len(list(csv.reader(f))) comes out at exactly twice the true number of records. If your counting program reports double, this is why.

writerow() writes one record. writerows() writes many: it takes a list of sequences — a list of lists, or a list of tuples — and writes each one as a line. It is exactly equivalent to a loop calling writerow(), just shorter.

Watch the s. writerow(row) takes one row. writerows(rows) takes a list of rows. Passing a flat list of numbers such as [1, 2, 3] to writerows() fails outright with Error: iterable expected, not int, because each element has to be a whole record. A flat list of strings is worse, because it does not fail: writerows(["ab", "cd"]) writes a,b and then c,d, one character per field.

This example also shows exactly when the writer decides to add quotes. Notice the shop name containing a comma, and the one containing double quotes.

import csv

items = [["Item", "Shop", "Price"],
         ["Notebook", "Sharma Stationers, Pune", 45],
         ["Geometry Box", 'Verma "Value" Mart', 120]]

f = open("items.csv", "w", newline="")
wr = csv.writer(f)
print("writerows() returned:", wr.writerows(items))
f.close()

print("--- file on disk ---")
print(open("items.csv").read())
print("--- rows back ---")
for r in csv.reader(open("items.csv", newline="")):
    print(r)

# a different separator
f = open("pipe.csv", "w", newline="")
csv.writer(f, delimiter="|").writerows(items)
f.close()
print("--- pipe.csv ---")
print(open("pipe.csv").read())
print("read with default comma:", list(csv.reader(open("pipe.csv", newline="")))[1])
print("read with delimiter='|':", list(csv.reader(open("pipe.csv", newline=""), delimiter="|"))[1])

Real output:

writerows() returned: None
--- file on disk ---
Item,Shop,Price
Notebook,"Sharma Stationers, Pune",45
Geometry Box,"Verma ""Value"" Mart",120

--- rows back ---
['Item', 'Shop', 'Price']
['Notebook', 'Sharma Stationers, Pune', '45']
['Geometry Box', 'Verma "Value" Mart', '120']
--- pipe.csv ---
Item|Shop|Price
Notebook|Sharma Stationers, Pune|45
Geometry Box|"Verma ""Value"" Mart"|120

read with default comma: ['Notebook|Sharma Stationers', ' Pune|45']
read with delimiter='|': ['Notebook', 'Sharma Stationers, Pune', '45']

writerows() returned None. Compare this with writerow(), which returned 19 in Section 2. A question asking you to distinguish the two methods wants both facts: one row versus many rows, and a character count versus None.

Quoting is decided per field, not per row. The default policy is csv.QUOTE_MINIMAL: quote a field only when it must be quoted. Look at line 2 of the file — Notebook and 45 are bare, but "Sharma Stationers, Pune" is quoted, because it contains the delimiter. A field is quoted when it contains the delimiter, the quote character, or a newline; otherwise it is written plain.

An internal quote is doubled, not backslashed. Verma "Value" Mart was stored as "Verma ""Value"" Mart" — the whole field wrapped in quotes, and each inner " written twice. That is the CSV convention, and it is a common trap for anyone parsing CSV by hand. The reader undid it perfectly: the field came back as Verma "Value" Mart, exactly what went in.

The delimiter is a shared secret. The pipe-separated file demonstrates why. When written with delimiter="|", the comma inside Sharma Stationers, Pune is no longer special, so that field was not quoted. But when the file is read back with the default comma delimiter, the reader splits on the wrong character and returns garbage: ['Notebook|Sharma Stationers', ' Pune|45'] — two fields, split at the one comma that happened to be in the data. The header row of the same file, which has no comma at all, comes back as a single field: ['Item|Shop|Price']. Tell the reader the same delimiter and the row is perfect again. Whatever delimiter and quotechar you write with, you must read with.

Two more conversions worth knowing, both observed by running writerow([1, 2.5, None, True, "hi"]) and reading it back:

'1,2.5,,True,hi\r\n'
['1', '2.5', '', 'True', 'hi']

None becomes an empty field — not the text None — so it reads back as ''. But True becomes the text 'True'. And every single field, including the number 1, comes back as a string. That last point is the whole of the next section.

csv.reader(fileobject) gives you a reader object. It is not a list. It is an iterator — you walk it with a for loop, and each turn of the loop hands you one record as a list of strings.

Those two words, list of strings, are where most marks are lost. Write the integer 88 into a CSV and you get back the string '88'. The file has no idea what a number is — it stores characters. This program writes a class marks file, reads it back, shows the type, then demonstrates the bug and the fix.

import csv

# make the file first
rows = [["Roll", "Name", "Marks"],
        [1, "Aarav Sharma", 88],
        [2, "Diya Nair", 92],
        [3, "Kabir Menon", 76],
        [4, "Ishita Rao", 61]]
with open("marks.csv", "w", newline="") as f:
    csv.writer(f).writerows(rows)

# --- what reader() actually hands you ---
with open("marks.csv", "r", newline="") as f:
    rd = csv.reader(f)
    header = next(rd)
    first = next(rd)
print("written  :", rows[1])
print("read back:", first)
print("Marks field type:", type(first[2]), "value:", repr(first[2]))

# --- the classic mistake ---
with open("marks.csv", "r", newline="") as f:
    rd = csv.reader(f)
    next(rd)
    total = 0
    try:
        for row in rd:
            total = total + row[2]
    except TypeError as e:
        print("TypeError:", e)

# --- the fix: int() ---
with open("marks.csv", "r", newline="") as f:
    rd = csv.reader(f)
    next(rd)
    total = count = 0
    topper = ""
    best = -1
    for roll, name, m in rd:
        m = int(m)
        total += m
        count += 1
        if m > best:
            best, topper = m, name
print("Total   =", total)
print("Count   =", count)
print("Average =", round(total / count, 2))
print("Topper  =", topper, "with", best)

Real output:

written  : [1, 'Aarav Sharma', 88]
read back: ['1', 'Aarav Sharma', '88']
Marks field type:  value: '88'
TypeError: unsupported operand type(s) for +: 'int' and 'str'
Total   = 317
Count   = 4
Average = 79.25
Topper  = Diya Nair with 92

The round trip is not type-preserving. [1, 'Aarav Sharma', 88] went in; ['1', 'Aarav Sharma', '88'] came out. The roll number and the marks are now text. type(first[2]) confirms str, and repr() shows the quotes.

The TypeError is the lucky case. Adding row[2] to an integer total raised unsupported operand type(s) for +: 'int' and 'str' — Python stopped you. But if you had initialised total = "" instead of 0, Python would have happily concatenated the marks into '88927661' and printed a nonsense total with no error at all. This is why int() is not optional. The rule: the moment a numeric field leaves reader(), convert it. Use int() for whole numbers like marks and roll numbers, float() for prices and percentages.

next(rd) skips the header. Call it once before the loop; it consumes the first record and returns it, so the loop starts at real data. Forgetting this is why a program crashes with ValueError: invalid literal for int() with base 10: 'Marks' — it tried to convert the header text.

Notice also the loop header for roll, name, m in rd:. Because every record is a three-element list, you can unpack it straight into three names instead of writing row[0], row[1], row[2]. This only works if every row has exactly three fields.

A reader is a one-pass iterator. Once you have walked it, it is empty. This trips up programs that try to count records and then loop over them again:

import csv
f = open("marks.csv", "r", newline="")
rd = csv.reader(f)
print("pass 1 count:", len(list(rd)))
print("pass 2 count:", len(list(rd)))
f.close()

with open("marks.csv", "r", newline="") as f:
    rd = csv.reader(f)
    next(rd)
    print("Students scoring above 80:")
    for roll, name, m in rd:
        if int(m) > 80:
            print(roll, name, m)
print("file closed?", f.closed)

Real output:

pass 1 count: 5
pass 2 count: 0
Students scoring above 80:
1 Aarav Sharma 88
2 Diya Nair 92
file closed? True

The second pass returns 0. If you need the data twice, either store it once with rows = list(rd) and reuse that list, or close and reopen the file. Note too that pass 1 counted 5, not 4 — list(rd) includes the header row, so the number of actual student records is len(list(rd)) - 1. And the with block closed the file for you, confirmed by f.closed printing True.