CSV Processing with Python: A Comprehensive Tutorial

Mokhtar Ebrahim Last Updated On:

CSV (Comma-Separated Values) files are one of the most common ways to store and share tabular data. These files consist of rows and columns, where each row represents a record, and the columns contain values separated by a delimiter, typically a comma.

Python provides several built-in methods to handle CSV files, allowing you to read, write, and manipulate the data efficiently.

This tutorial will provide you with in-depth knowledge about processing CSV files using Python.

 

Table of Contents hide

 

Read CSV using the open() Method

You can use the open() method and open the file in text mode and then iterate through each line, splitting the values using the comma as a delimiter.
Here’s a simple example using this sample file:

with open('sample.csv', 'r') as file:
    for line in file:
        row = line.strip().split(',')
        print(row)

Output:

['"Index"', '"Name"', '"Age"', '"Favorite Color"']
['1', 'John', '6', 'Yellow']
['2', 'Ronald', '17', 'Red']
['3', 'Ruby', '23', 'Blue']
['4', 'Sarah', '53', 'Green']
['5', 'Timothy', '12', 'Green']
['6', 'Carol', '25', 'Red']
['7', 'Leo', '67', 'Blue']
['8', 'Quinn', '22', 'Green']
['9', 'Susan', '64', 'Orange']
['10', 'Luis', '79', 'Red']

Here, the open() function opens the file ‘sample.csv’ in read mode (‘r’), and the strip() method removes any leading or trailing whitespace from each line.

The split(',') method then separates each line by the comma, providing a list of values for each row.

Read a Specific Row

You can read a specific row by iterating through the CSV file and selecting the desired row index. Let’s read the third row (index 2) from thesample.csv file.

import csv
def read_specific_row(row_number):
    with open('sample.csv', 'r') as file:
        reader = csv.reader(file)
        for index, row in enumerate(reader):
            if index == row_number:
                print(row)
                break

# Read the third row (index 2)
read_specific_row(2)

Output:

['2', 'Ronald', '17', 'Red']

Read a Specific Column

Reading a specific column involves selecting the same index from each row. Let’s read the “Name” column (index 1) from thesample.csv file.

def read_specific_column(column_number):
    with open('sample.csv', 'r') as file:
        reader = csv.reader(file)
        for row in reader:
            print(row[column_number])

# Read the "Name" column (index 1)
read_specific_column(1)

Output:

'Name'
'John'
'Ronald'
'Ruby'
'Sarah'
'Timothy'
'Carol'
'Leo'
'Quinn'
'Susan'
'Luis'

 

Read CSV using Python csv.reader

For more structured CSV reading, Python provides a dedicated csv module.

Using the csv.reader function gives you more control and makes code more readable.
Here’s an example:

import csv
with open('sample.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

Output:

['"Index"', '"Name"', '"Age"', '"Favorite Color"']
['1', 'John', '6', 'Yellow']
['2', 'Ronald', '17', 'Red']
['3', 'Ruby', '23', 'Blue']
['4', 'Sarah', '53', 'Green']
['5', 'Timothy', '12', 'Green']
['6', 'Carol', '25', 'Red']
['7', 'Leo', '67', 'Blue']
['8', 'Quinn', '22', 'Green']
['9', 'Susan', '64', 'Orange']
['10', 'Luis', '79', 'Red']

Here, you import the csv module and use the csv.reader() method, passing in the opened file.

This returns an iterator, allowing you to loop through the rows just like when using the open() method.

The csv.reader takes care of splitting the lines by the comma.

Get the Number of Rows

You can iterate through the rows, counting them as it goes along:

import csv
def get_number_of_rows(filename):
    with open(filename, 'r') as file:
        reader = csv.reader(file)
        return sum(1 for row in reader)

rows_count = get_number_of_rows('sample.csv')
print("Number of rows (including the header):", rows_count)

Output:

Number of rows (including the header): 11

The result gives you the number of rows in the CSV file, and it includes the header row in the count.

 

Handling Different Delimiters

If your CSV file is delimited by any delimiter other than a comma, you can specify the delimiter using the delimiter parameter.
Here’s an example of reading a file with semicolons as delimiters from this sample file:

import csv
with open('sample_semicolon.csv', 'r') as file:
    reader = csv.reader(file, delimiter=';')
    for row in reader:
        print(row)

Output:

['"Index"', '"Name"', '"Age"', '"Favorite Color"']
['1', 'John', '6', 'Yellow']
['2', 'Ronald', '17', 'Red']
['3', 'Ruby', '23', 'Blue']
['4', 'Sarah', '53', 'Green']
['5', 'Timothy', '12', 'Green']
['6', 'Carol', '25', 'Red']
['7', 'Leo', '67', 'Blue']
['8', 'Quinn', '22', 'Green']
['9', 'Susan', '64', 'Orange']
['10', 'Luis', '79', 'Red']

By providing the delimiter argument, you can define a custom character to separate the values.

In this case, the semicolon ‘;’ is the delimiter, so the csv.reader uses it to split each line into columns.

 

Reading CSV files into Dictionaries using csv.DictReader

With csv.DictReader, each row in the CSV file is returned as an OrderedDict, where the keys are the fieldnames from the first row.
Here’s how you can do it:

import csv
with open('sample.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(row)

Output:

{'Index': '1', 'Name': 'John', 'Age': '6', 'Favorite Color': 'Yellow'}
{'Index': '2', 'Name': 'Ronald', 'Age': '17', 'Favorite Color': 'Red'}
{'Index': '3', 'Name': 'Ruby', 'Age': '23', 'Favorite Color': 'Blue'}
{'Index': '4', 'Name': 'Sarah', 'Age': '53', 'Favorite Color': 'Green'}
{'Index': '5', 'Name': 'Timothy', 'Age': '12', 'Favorite Color': 'Green'}
{'Index': '6', 'Name': 'Carol', 'Age': '25', 'Favorite Color': 'Red'}
{'Index': '7', 'Name': 'Leo', 'Age': '67', 'Favorite Color': 'Blue'}
{'Index': '8', 'Name': 'Quinn', 'Age': '22', 'Favorite Color': 'Green'}
{'Index': '9', 'Name': 'Susan', 'Age': '64', 'Favorite Color': 'Orange'}
{'Index': '10', 'Name': 'Luis', 'Age': '79', 'Favorite Color': 'Red'}

Here, csv.DictReader reads the first row of the CSV file and uses it as keys for the dictionaries. Subsequent rows are read into dictionaries with these keys, making it easy to reference individual fields by name.

 

Writing CSV Files Using the open() Method

You can use the open() method with write mode (‘w’) and write lines using the write() method.
Here’s a quick example:

data = [['Name', 'Age', 'Occupation'], ['John', '32', 'Engineer'], ['Jane', '28', 'Doctor']]
with open('output.csv', 'w') as file:
    for row in data:
        file.write(','.join(row) + '\n')

Output:
File output.csv will have:

Name,Age,Occupation
John,32,Engineer
Jane,28,Doctor

Here, the open() function is used with the ‘w’ mode to open a file for writing.

Inside the loop, the ','.join(row) concatenates the values with commas in between, and the write() method writes each line to the file.

 

Write CSV Files Using the csv.writer

A more structured way to write CSV files is to use the csv.writer method from the csv module:

import csv
data = [['Name', 'Age', 'Occupation'], ['John', '32', 'Engineer'], ['Jane', '28', 'Doctor']]
with open('output.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(data)

Output:
File output.csv will have:

Name,Age,Occupation
John,32,Engineer
Jane,28,Doctor

Here, the csv.writer() method provides an easy way to write rows to the file using the writer.writerows() function.

The newline='' argument ensures that the line endings are handled correctly across different platforms.

 

Writing Dictionaries using csv.DictWriter

The csv module also provides a convenient way to write dictionaries into CSV files using csv.DictWriter. It’s especially useful when the data is already in a dictionary format.
Here’s how to use it:

import csv
data = [
    {'Name': 'John', 'Age': '32', 'Occupation': 'Engineer'},
    {'Name': 'Jane', 'Age': '28', 'Occupation': 'Doctor'}
]
with open('output.csv', 'w', newline='') as file:
    writer = csv.DictWriter(file, fieldnames=['Name', 'Age', 'Occupation'])
    writer.writeheader()
    writer.writerows(data)

Output:
File output.csv will have:

Name,Age,Occupation
John,32,Engineer
Jane,28,Doctor

With csv.DictWriter, you provide the fieldnames as a list of keys that determine the order of the columns.

The writeheader() method writes the keys as the header row, and writer.writerows(data) writes the dictionaries as rows in the CSV file.

 

Handling Quote Characters

When values contain special characters like commas or newlines, you can use quotes. Specify the quotechar and quoting parameters.
Example:

import csv
with open('quoted.csv', 'w', newline='') as file:
    writer = csv.writer(file, quotechar='"', quoting=csv.QUOTE_MINIMAL)
    writer.writerow(['Name', 'Age', 'Occupation, Title'])

Output:
File quoted.csv will have:

Name,Age,"Occupation, Title"

By setting quotechar and quoting, you can control how special characters are handled. In the above example, the third value is enclosed in quotes since it contains a comma.

 

Manipulating Columns

Adding Columns

Adding a new column to a CSV file can be done by reading the file, adding the new column to each row, and then writing the modified rows back to a new file.
Here’s an example:

import csv

# Adding a new column 'Salary'
with open('sample.csv', 'r') as infile, open('output.csv', 'w', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)

    # Write headers with the new column
    headers = next(reader)
    headers.append('Salary')
    writer.writerow(headers)

    # Write rows with a new column value
    for row in reader:
        row.append('50000')
        writer.writerow(row)

Output:
File output.csv will have:

Index,Name,Age,Favorite Color,Salary
1,John,6,Yellow,50000
2,Ronald,17,Red,50000
3,Ruby,23,Blue,50000
4,Sarah,53,Green,50000
5,Timothy,12,Green,50000
6,Carol,25,Red,50000
7,Leo,67,Blue,50000
8,Quinn,22,Green,50000
9,Susan,64,Orange,50000
10,Luis,79,Red,50000

Deleting Columns

Deleting a column can be achieved by omitting that column while writing the new file.
Example:

import csv
with open('input.csv', 'r') as infile:
    reader = csv.reader(infile)    
    with open('output.csv', 'w', newline='') as outfile:
        writer = csv.writer(outfile)
        for row in reader:
            # Removing the Age column (index 2)
            del row[2]
            # Writing the modified row to the new file
            writer.writerow(row)

Output:
File output.csv will have:

Index,Name,Favorite Color
1,John,Yellow
2,Ronald,Red
3,Ruby,Blue
4,Sarah,Green
5,Timothy,Green
6,Carol,Red
7,Leo,Blue
8,Quinn,Green
9,Susan,Orange
10,Luis,Red

In this example, the ‘Age’ column is removed from both the headers and the individual rows before writing to the new file.

Renaming Column Header

Here’s an example of how to rename the “Favorite Color” column to “Color” in the sample.csv file:

import csv
with open('sample.csv', 'r') as file:
    reader = csv.reader(file)
    rows = list(reader)

# Modify the header
rows[0][3] = 'Color'

# Write the data back to the file
with open('sample.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(rows)

Output:

"Index","Name","Age","Color"
1,John,6,Yellow
2,Ronald,17,Red
3,Ruby,23,Blue
4,Sarah,53,Green
5,Timothy,12,Green
6,Carol,25,Red
7,Leo,67,Blue
8,Quinn,22,Green
9,Susan,64,Orange
10,Luis,79,Red

 

Manipulating Rows

Adding Rows

Appending rows to a CSV file is straightforward. You can open the file in append mode (‘a’) and write the new rows.
Here’s an example:

import csv
new_rows = [['11', 'Jake', '40', 'White'], ['12', 'Emily', '35', 'Black']]
with open('sample.csv', 'a', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(new_rows)

Output:
File sample.csv will have:

"Index","Name","Age","Favorite Color"
1,John,6,Yellow
2,Ronald,17,Red
3,Ruby,23,Blue
4,Sarah,53,Green
5,Timothy,12,Green
6,Carol,25,Red
7,Leo,67,Blue
8,Quinn,22,Green
9,Susan,64,Orange
10,Luis,79,Red
11,Jake,40,White
12,Emily,35,Black

Here, opening the file in append mode allows the new rows to be added at the end of the file without overwriting the existing content.

Deleting Rows (Filtering)

Deleting rows requires reading the file, filtering out the unwanted rows, and writing the remaining rows back to the file.
Example:

import csv
with open('sample.csv', 'r') as infile, open('output.csv', 'w', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    writer.writerow(next(reader))

    # Write only the rows that have Age greater than 50
    for row in reader:
        if int(row[2]) > 50:
            writer.writerow(row)

Output:
File output.csv will have:

Index,Name,Age,Favorite Color
4,Sarah,53,Green
7,Leo,67,Blue
9,Susan,64,Orange
10,Luis,79,Red

Here, the code filters out the rows with ‘Age’ less than 50 and writes only the remaining rows to the new file.

Replacing Values

Let’s say you want to replace the age ’17’ with ’18’. Here’s how you can achieve this:

import csv
def replace_values(filename, old_value, new_value):
    with open(filename, 'r') as file:
        reader = csv.reader(file)
        rows = [row for row in reader]

    # Replace the old value with the new value
    for row in rows:
        for index, value in enumerate(row):
            if value == old_value:
                row[index] = new_value

    # Write the updated data back to the file
    with open(filename, 'w', newline='') as file:
        writer = csv.writer(file)
        writer.writerows(rows)
replace_values('sample.csv', '17', '18')

Output:

"Index","Name","Age","Favorite Color"
1,John,6,Yellow
2,Ronald,18,Red
3,Ruby,23,Blue
4,Sarah,53,Green
5,Timothy,12,Green
6,Carol,25,Red
7,Leo,67,Blue
8,Quinn,22,Green
9,Susan,64,Orange
10,Luis,79,Red

As you can see, the age for the second row was 17, now it’s 18.

 

Sorting Data

You can sort the rows based on one or more columns using sorted() function.
Here’s an example of sorting by age:

import csv
with open('sample.csv', 'r') as file:
    reader = csv.reader(file)
    rows = list(reader)

# Sort by Age (index 2)
rows[2:] = sorted(rows[2:], key=lambda row: int(row[2]))
with open('sorted.csv', 'w', newline='') as file:
    writer = csv.writer(file)
    writer.writerows(rows)

Output:
File sorted.csv will have:

Index,Name,Age,Favorite Color
1,John,6,Yellow
5,Timothy,12,Green
2,Ronald,17,Red
8,Quinn,22,Green
3,Ruby,23,Blue
6,Carol,25,Red
12,Emily,35,Black
11,Jake,40,White
4,Sarah,53,Green
9,Susan,64,Orange
7,Leo,67,Blue
10,Luis,79,Red

In this example, the code reads all rows into a list, then sorts the rows (excluding the header) by the ‘Age’ column using the sorted function and a lambda function as the key. The sorted rows are then written to a new CSV file.

 

Merging and Joining CSV Files

Merging and joining CSV files is a common task when you have related data spread across multiple files.

You can achieve this by reading the files and matching the rows based on common keys or columns.
Here’s an example that joins two CSV files on a common ‘ID’ column:
file1.csv:

ID,Name
1,John
2,Jane

file2.csv:

ID,Age
1,32
2,28

Code to merge these files:

import csv
file2_data = {}
with open('file2.csv', 'r') as file:
    reader = csv.reader(file)
    next(reader) # Skip header
    for row in reader:
        file2_data[row[0]] = row[1]

# Read file1.csv and join with file2.csv
with open('file1.csv', 'r') as infile, open('output.csv', 'w', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    writer.writerow(next(reader) + ['Age'])

    # Join and write rows
    for row in reader:
        writer.writerow(row + [file2_data[row[0]]])

Output:
File output.csv will have:

ID,Name,Age
1,John,32
2,Jane,28

In this example, file2.csv is first read into a dictionary using the ‘ID’ column as the key.

Then, file1.csv is read row by row, and the ‘Age’ column from file2.csv is appended to each row using the ‘ID’ as the common key.

 

Handling Missing Values

Missing values in a CSV file can lead to errors or inaccurate results when processing the data.

You can handle missing values by skipping them, filling them with a default value, or using a data imputation method.
Here’s an example that fills missing values with a default value:

import csv
with open('missing_values.csv', 'r') as infile, open('output.csv', 'w', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        # Replace missing values (empty strings) with 'N/A'
        cleaned_row = [value if value != '' else 'N/A' for value in row]
        writer.writerow(cleaned_row)

missing_values.csv content:

Name,Age,Occupation
John,,Engineer
Jane,28,

Output:
File output.csv will have:

Name,Age,Occupation
John,N/A,Engineer
Jane,28,N/A

In this example, missing values are represented by empty strings in the CSV file. The code reads each row and replaces the missing values with ‘N/A’ before writing the cleaned rows to a new file.

 

Handling Duplicate Rows

Duplicate rows in a CSV file can skew your data analysis. You’ll want to identify and remove duplicates to ensure the accuracy of your work.
Here’s an example of how to remove duplicate rows based on all columns:

import csv
seen_rows = set()
with open('duplicates.csv', 'r') as infile, open('output.csv', 'w', newline='') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        row_tuple = tuple(row)
        if row_tuple not in seen_rows:
            writer.writerow(row)
            seen_rows.add(row_tuple)

duplicates.csv content:

Name,Age,Occupation
John,32,Engineer
Jane,28,Doctor
John,32,Engineer

Output:
File output.csv will have:

Name,Age,Occupation
John,32,Engineer
Jane,28,Doctor

In this example, a set called seen_rows keeps track of the rows that have already been processed. If a row is encountered that’s already in the set, it’s skipped, effectively removing duplicates from the output file.

 

CSV Files with Different Encodings

Files can be encoded in different character sets, such as UTF-8 or ISO-8859-1.

Reading and writing CSV files with different encodings requires specifying the encoding in Python.
Here’s an example of reading a file encoded in ISO-8859-1 and writing it in UTF-8:

import csv
with open('input.csv', 'r', encoding='ISO-8859-1') as infile, open('output.csv', 'w', newline='', encoding='UTF-8') as outfile:
    reader = csv.reader(infile)
    writer = csv.writer(outfile)
    for row in reader:
        writer.writerow(row)

By specifying the encoding parameter in the open function, you can handle files with different encodings.

In this example, the code reads a file encoded in ISO-8859-1 and writes it using UTF-8.
This can be essential when dealing with international characters and symbols that may not be represented in standard ASCII encoding.

 

Reading and Writing Large Files

When working with large CSV files that don’t fit into memory, you can read and write the file line by line to reduce memory usage.
Here’s an example of reading and writing large files line by line:

with open('large_input.csv', 'r') as infile, open('large_output.csv', 'w', newline='') as outfile:
    for line in infile:
        outfile.write(line)

This code reads a large CSV file one line at a time and writes each line to a new file. By avoiding loading the entire file into memory, it enables you to work with files that exceed the available memory.
While this method is memory-efficient, it might not be suitable for all data processing tasks, especially those requiring random access to the file’s content. However, for simple transformations or filtering, it can be very useful.

 

Overview of Third-party Libraries

While Python’s built-in CSV module is powerful, third-party libraries can provide additional features and optimizations.

agate

Agate is a data analysis library that extends the capabilities of Python’s built-in CSV handling.

import agate
table = agate.Table.from_csv('data.csv')
table.print_table()

Output:

| Index | Name    | Age | Favorite Color |
| ----- | ------- | --- | -------------- |
|     1 | John    |   6 | Yellow         |
|     2 | Ronald  |  17 | Red            |
|     3 | Ruby    |  23 | Blue           |
|     4 | Sarah   |  53 | Green          |
|     5 | Timothy |  12 | Green          |
|     6 | Carol   |  25 | Red            |
|     7 | Leo     |  67 | Blue           |
|     8 | Quinn   |  22 | Green          |
|     9 | Susan   |  64 | Orange         |
|    10 | Luis    |  79 | Red            |

Agate provides functionalities like SQL-style queries, statistics, and more. It’s especially useful for complex data analysis tasks.

 

Benchmark Reading

When working with CSV files, performance may vary based on the method used to read the data.

Let’s compare the performance of open(), csv.reader, csv.DictReader, and pandas.read_csv.

We’ll use a sample file with 1000 rows and 10 columns.

import csv
import pandas as pd
import timeit

# Using open()
def read_with_open():
    with open('data.csv', 'r') as file:
        return file.readlines()

# Using csv.reader
def read_with_csv_reader():
    with open('data.csv', 'r') as file:
        return list(csv.reader(file))

# Using csv.DictReader
def read_with_csv_dictreader():
    with open('data.csv', 'r') as file:
        return list(csv.DictReader(file))

# Using pandas read_csv
def read_with_pandas():
    return pd.read_csv('data.csv')

print('open():', timeit.timeit(read_with_open, number=1000))
print('csv.reader:', timeit.timeit(read_with_csv_reader, number=1000))
print('csv.DictReader:', timeit.timeit(read_with_csv_dictreader, number=1000))
print('pandas read_csv:', timeit.timeit(read_with_pandas, number=1000))

Output:

open(): 1.220612900040578
csv.reader: 3.8335254000267014
csv.DictReader: 4.351687000016682
pandas read_csv: 4.525356799946167

open() is the fastest but provides the least functionality. pandas.read_csv offers the most features but might be slower for simple tasks.

 

Benchmark Writing

Writing to CSV files also has different methods. Let’s compare open(), csv.writer, csv.DictWriter, and pandas.to_csv.

Read more on how to write CSV files using Pandas to_csv.

We’ll use the same sample file used in the above benchmark to write its content.

import csv
import pandas as pd
import timeit

# Read the data from sample.csv
with open('sample.csv', 'r') as file:
    reader = csv.DictReader(file)
    data = [row for row in reader]

# Using open()
def write_with_open():
    with open('output.csv', 'w') as file:
        for row in data:
            file.write(','.join(map(str, row.values())) + '\n')

# Using csv.writer
def write_with_csv_writer():
    with open('output.csv', 'w', newline='') as file:
        writer = csv.writer(file)
        writer.writerow(data[0].keys())  # Write headers
        for row in data:
            writer.writerow(row.values())

# Using csv.DictWriter
def write_with_csv_dictwriter():
    with open('output.csv', 'w', newline='') as file:
        writer = csv.DictWriter(file, fieldnames=data[0].keys())
        writer.writeheader()
        writer.writerows(data)

# Using pandas to_csv
def write_with_pandas():
    df = pd.DataFrame(data)
    df.to_csv('output.csv', index=False)

print('open():', timeit.timeit(write_with_open, number=1000))
print('csv.writer:', timeit.timeit(write_with_csv_writer, number=1000))
print('csv.DictWriter:', timeit.timeit(write_with_csv_dictwriter, number=1000))
print('pandas to_csv:', timeit.timeit(write_with_pandas, number=1000))

Output:

open(): 4.888178199995309
csv.writer: 6.31797530001495
csv.DictWriter: 8.040658099984284
pandas to_csv: 7.672513599973172

Again, these timings reflect the trade-offs between simplicity and functionality. open() is faster but requires manual handling, while pandas.to_csv provides more features at the cost of performance.

 

csv.reader not working (Issues and Fixes)

File Not Found: Ensure the CSV file’s name and path are correct. If the CSV file is not in the same directory as your Python script, you will need to provide the full path to the file.

Encoding Errors: If your CSV file contains special characters, you might run into encoding issues. You can specify the encoding when opening the file:

with open('file.csv', 'r', encoding='utf-8') as file:

Delimiter Issues: If your CSV file uses a delimiter other than a comma, you will need to specify that delimiter when creating the csv.reader object:

reader = csv.reader(file, delimiter=';')

Newline Issues: Sometimes, the way newlines are handled can cause problems when reading a CSV file. You can add the newline='' parameter when opening the file to handle this:

with open('file.csv', 'r', newline='') as file:

 

csv.writer not working (Issues and Fixes)

File Permission Error: If you’re trying to write to a location where you don’t have permission, you’ll encounter an error. Try writing to a location where you know you have write permissions.

Missing ‘newline’ Argument: When writing to a CSV file, it’s often recommended to include newline='' when opening the file. This helps ensure that newlines are handled consistently across different platforms.

Writing Inside a ‘read’ Mode File: Make sure you’re opening the file with 'w' or 'a' (write or append mode) rather than 'r' (read mode).

Incorrect Data Structure: Ensure that the data you’re trying to write is in the correct format, typically a list of lists where each inner list represents a row in the CSV.

CSV File Open Elsewhere: If the file you’re trying to write to is open in another program, like Excel, you might encounter issues. Make sure the file is closed in other programs before writing to it.

Specifying a Delimiter: If you need to write a CSV file with a different delimiter (e.g., a semicolon instead of a comma), you can specify the delimiter parameter:

writer = csv.writer(file, delimiter=';')

Special Characters Encoding: If you’re dealing with special characters, ensure that you’re using an appropriate encoding. You can specify the encoding when opening the file:

with open('file.csv', 'w', newline='', encoding='utf-8') as file:

Related posts

  1. JSON Manipulation and Conversion Techniques in Python
Leave a Reply

Your email address will not be published. Required fields are marked *