3. CSV and JSON in Python (14m)

Question 1

Explain the following code in Detail:

import csv

with open('museum.csv', newline='') as csvfile:
    art_reader = csv.reader(csvfile, delimiter='|')
    rows = list(art_reader)
    for row in rows[:2]:
        print(', '.join(row))
        
with open('museum.csv', newline='') as csvfile:
    art_reader = csv.DictReader(csvfile, delimiter='|')
    rows = list(art_reader)
    for row in rows[1:3]:
        print(row['group1'])

Answer 1

Certainly! Let’s break down the code step by step:

```python
import csv
~~~
This line imports the csv module, which provides functionality for reading and writing CSV files.

```python
with open(‘museum.csv’, newline=’’) as csvfile:
~~~
This line opens the file named ‘museum.csv’ in the current directory using the open function. The file is opened in read mode (‘r’). The newline='' argument is provided to handle newlines properly in CSV files.

The with statement is used to create a context manager that automatically handles the opening and closing of the file. It ensures that the file is properly closed after the indented block of code, even if an exception occurs.

```python
art_reader = csv.reader(csvfile, delimiter=’|’)
rows = list(art_reader)
~~~
These lines create a CSV reader object called art_reader using the csv.reader function. The csv.reader function takes the opened file csvfile as an argument and specifies the delimiter as the pipe symbol (|) using the delimiter='|' parameter. The art_reader object is then converted to a list called rows using the list function.

At this point, rows contains a list of lists, where each inner list represents a row in the CSV file. Each value in the CSV file is separated by the pipe symbol.

```python
for row in rows[:2]:
print(‘, ‘.join(row))
~~~
This loop iterates over the first two rows of the rows list using a slice (rows[:2]). For each row, it joins the individual values of the row with a comma and space using ', '.join(row), and then prints the resulting string to the console. This code snippet prints the first two rows of the CSV file.

```python
with open(‘museum.csv’, newline=’’) as csvfile:
art_reader = csv.DictReader(csvfile, delimiter=’|’)
rows = list(art_reader)
~~~
This code block opens the ‘museum.csv’ file again in the same manner as before. However, this time, it uses csv.DictReader to create a reader object called art_reader. csv.DictReader reads the CSV file and interprets the first row as the header row, treating it as the keys for a dictionary. The delimiter='|' parameter specifies the pipe symbol as the delimiter.

The art_reader object is then converted to a list called rows using the list function. Each row in rows is represented as a dictionary, where the keys are the header names and the values are the corresponding values from each row in the CSV file.

```python
for row in rows[1:3]:
print(row[‘group1’])
~~~
This loop iterates over the second and third rows of the rows list using a slice (rows[1:3]). For each row, it accesses the value corresponding to the key 'group1' from the dictionary row and prints it to the console. This code snippet prints the values of the 'group1' column for the second and third rows of the CSV file.

In summary, the code reads a CSV file named ‘museum.csv’ with the pipe symbol (|) as the delimiter. It demonstrates two approaches: using csv.reader to read the file as a list of lists, and using csv.DictReader to read the file as a list of dictionaries with the header row as the keys. It then prints specific rows or columns of the CSV file to the console.

Question 2

Explain the following code:

import csv

with open('teachers.csv', 'a') as csvfile:
    fieldnames = ['first_name', 'last_name', 'topic']
    teachwriter = csv.DictWriter(csvfile, fieldnames=fieldnames)
    
    teachwriter.writeheader()
    teachwriter.writerow({
        'first_name': 'Kenneth',
        'last_name': 'Love',
        'topic': 'Python'
    })
    teachwriter.writerow({
        'first_name': 'Alena',
        'last_name': 'Holligan',
        'topic': 'PHP'
    })
    
    # run python teachers.py & cat teachers.csv

With above code, now Python REPL is open and following is run:
~~~
python teachers.py
cat teachers.csv
~~~

What does the above code do? what results it yields?

Answer 2

The given code is performing the following actions:

1. It imports the csv module, which provides functionality for working with CSV (Comma Separated Values) files.
2. The code opens a file named “teachers.csv” in “append” mode using the open() function and associates it with the csvfile variable. The file will be created if it doesn’t exist or appended to if it does.
3. A list called fieldnames is created with three strings: ‘first_name’, ‘last_name’, and ‘topic’. These strings represent the column names or fieldnames for the CSV file.
4. An instance of the DictWriter class from the csv module is created and assigned to the teachwriter variable. This class allows writing dictionaries to a CSV file, where each dictionary represents a row and the keys correspond to the fieldnames.
5. The writeheader() method is called on the teachwriter object to write the fieldnames as the header row in the CSV file.
6. Two writerow() calls are made to add rows to the CSV file. Each row is specified as a dictionary with keys matching the fieldnames and values representing the data for each field.
7. After the code snippet, there is a comment indicating the intention to run the Python script teachers.py and then use the cat command to display the contents of the resulting teachers.csv file.

The expected results are as follows:

• Running python teachers.py executes the code and performs the file operations described above.
• The cat teachers.csv command displays the contents of the teachers.csv file. In this case, it would show the following output:

first_name,last_name,topic
Kenneth,Love,Python
Alena,Holligan,PHP

The CSV file will have three columns: ‘first_name’, ‘last_name’, and ‘topic’. The subsequent rows contain the corresponding data for each column, as specified in the writerow() calls.

Question 3

Explain the following in detail with examples:

1. Dictwriter
2. writeheader()
3. writerow()
4. cat file.csv

Answer 3

1. DictWriter:
   DictWriter is a class provided by the csv module in Python that facilitates writing dictionaries as rows in a CSV file. It allows you to write structured data to a CSV file where each dictionary represents a row and the keys of the dictionary correspond to the fieldnames or column names in the CSV file.

Here’s an example that demonstrates the usage of DictWriter:

```python
import csv

data = [
{‘name’: ‘John’, ‘age’: 25, ‘city’: ‘New York’},
{‘name’: ‘Emma’, ‘age’: 30, ‘city’: ‘San Francisco’},
{‘name’: ‘Michael’, ‘age’: 40, ‘city’: ‘Chicago’}
]

fieldnames = [‘name’, ‘age’, ‘city’]

with open(‘output.csv’, ‘w’, newline=’’) as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

writer.writeheader()  # Write the fieldnames as the header row

for row in data:
    writer.writerow(row) ~~~

In the above example, a list of dictionaries (data) is defined, representing the rows to be written to the CSV file. The fieldnames list specifies the column names for the CSV file.

The DictWriter is instantiated with the csvfile (the output file) and the fieldnames. The writeheader() method is called to write the fieldnames as the header row in the CSV file. Then, a loop is used to write each row from the data list using the writer.writerow() method.

2. writeheader():
   The writeheader() method is used with a DictWriter object to write the fieldnames or column names as the header row in the CSV file. It should be called before writing any rows of data.

Here’s an example illustrating the usage of writeheader():

```python
import csv

data = [
{‘name’: ‘John’, ‘age’: 25, ‘city’: ‘New York’},
{‘name’: ‘Emma’, ‘age’: 30, ‘city’: ‘San Francisco’},
{‘name’: ‘Michael’, ‘age’: 40, ‘city’: ‘Chicago’}
]

fieldnames = [‘name’, ‘age’, ‘city’]

with open(‘output.csv’, ‘w’, newline=’’) as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

writer.writeheader()  # Write the fieldnames as the header row

for row in data:
    writer.writerow(row) ~~~

In the above example, the writeheader() method is called after creating the DictWriter object (writer). It writes the fieldnames ‘name’, ‘age’, and ‘city’ as the first row in the CSV file.

3. writerow():
   The writerow() method is used with a DictWriter object to write a single row of data to the CSV file. The data is provided as a dictionary, where the keys of the dictionary correspond to the fieldnames or column names.

Here’s an example that demonstrates the usage of writerow():

```python
import csv

data = [
{‘name’: ‘John’, ‘age’: 25, ‘city’: ‘New York’},
{‘name’: ‘Emma’, ‘age’: 30, ‘city’: ‘San Francisco’},
{‘name’: ‘Michael’, ‘age’: 40, ‘city’: ‘Chicago’}
]

fieldnames = [‘name’, ‘age’, ‘city’]

with open(‘output.csv’, ‘w’, newline=’’) as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

writer.writeheader()  # Write the fieldnames as the header row

for row in data:
    writer.writerow(row) ~~~

In the above example, the writerow() method is called inside a loop to write each dictionary from the data list as a row in the CSV file. Each dictionary represents a single row, where the keys (‘name’, ‘age’, ‘city’) correspond to the fieldnames, and the values represent the data for each field.

4. cat file.csv:
   The cat command is used in Unix-like operating systems (including Linux and macOS) to display the contents of a file in the terminal. When you run cat file.csv, it outputs the content of the file.csv file to the terminal.

For example, if you have a file named data.csv with the following contents:

Name,Age,City
John,25,New York
Emma,30,San Francisco
Michael,40,Chicago

Running cat data.csv in the terminal will display the contents of the file:

Name,Age,City
John,25,New York
Emma,30,San Francisco
Michael,40,Chicago

The cat command is a simple way to quickly view the contents of a file without opening it in an editor or processing it further.

Question 4

Explain the following code:
~~~
import json

with open(‘148.json’) as artfile:
art = json.load(artfile)
print(art[‘description’])
~~~

while 148.json contains:
~~~
{
“accession_number”: “2000.12.13”,
“artist”: “Martha Hale Harvey”,
“continent”: “North America”,
“country”: “United States”,
“creditline”: “The McClurg Photography Purchase Fund”,
“culture”: null,
“dated”: “1899”,
“department”: “Photography & New Media”,
“description”: “boat with 2 masts in front of a bridge with a lift gate; 2 rowboats in water at L; buildings at L; trees at R”,
“dimension”: “9 1/4 x 11 1/2 in. (23.5 x 29.21 cm) (image, sheet)\r\n11 3/4 x 13 1/2 in. (29.85 x 34.29 cm) (mount)”,
“id”: “http://api.artsmia.org/objects/148”,
“image”: “valid”,
“image_copyright”: “”,
“image_height”: 3544,
“image_width”: 4388,
“life_date”: “American, 1862-1949”,
“marks”: “Inscription; Signature “,
“medium”: “platinum print”,
“nationality”: “American”,
“provenance”: “”,
“restricted”: 0,
“rights_type”: “Public Domain”,
“role”: “Artist”,
“room”: “Not on View”,
“style”: “19th century”,
“text”: “”,
“title”: “Annisquam, Massachusetts”
}
~~~

What result will the above code will yield? And explain json.load in detail.

Answer 4

The given code snippet reads a JSON file named “148.json” and extracts the value associated with the key ‘description’ from the JSON data. Here’s a detailed explanation:

1. The code starts by importing the json module, which provides functions for working with JSON data in Python.
2. The open() function is used to open the file named “148.json” in the default reading mode. The file is associated with the artfile variable using a with statement, ensuring that the file is properly closed after it’s used.
3. The json.load() function is called, passing the artfile as the argument. This function reads the contents of the JSON file and parses it into a Python object. In this case, the parsed JSON data is stored in the art variable.
4. The print() function is used to display the value associated with the key ‘description’ from the art dictionary: art['description'].

Based on the contents of “148.json” provided, the output of the code will be:

boat with 2 masts in front of a bridge with a lift gate; 2 rowboats in water at L; buildings at L; trees at R

Explanation of json.load():
The json.load() function is used to parse JSON data from a file-like object (such as a file opened with open()) and convert it into a Python object.

Here’s an overview of how json.load() works:

1. It takes a file-like object as its argument. The file should contain valid JSON data.
2. The function reads the contents of the file and parses it into a Python object. The resulting object can be a dictionary, a list, a string, a number, a Boolean value, or None, depending on the JSON data structure.
3. If the JSON data represents an object (i.e., a dictionary), the resulting Python object will be a dictionary. If the JSON data represents an array (i.e., a list), the resulting Python object will be a list.
4. Once the JSON data is parsed, the function returns the resulting Python object, which can be assigned to a variable for further processing.

In the provided code, json.load(artfile) reads the JSON data from the “148.json” file and parses it into a Python dictionary, which is then assigned to the art variable. Consequently, you can access the values in the JSON data by using the corresponding keys of the art dictionary, as demonstrated in the code snippet with art['description'].

Question 5

The following code is run in REPL on sequence one by one, explain the code and what result it will yield:

import json
nums = json.loads("[1, 2, 3]")
nums[2]
json.dumps([5, 4, 3, 2, 1])
me = {'first_name': 'Kenneth', 'last_name': 'Love', 'topic': 'Python'}
str(me)
json.dumps(me)
craig = {'first_name': 'Craig', 'last_name': 'Dennis', 'topic': 'Java'}
with open('teachers.json', 'a') as teacherfile:
    json.dump([me, craig], teacherfile)

Answer 5

Let’s break down the code and explain the actions performed at each step, along with the expected results:

1. import json: This line imports the json module, which provides functions for working with JSON data in Python.
2. nums = json.loads("[1, 2, 3]"): The json.loads() function is used to parse a JSON-formatted string and convert it into a Python object. In this case, the JSON-formatted string is "[1, 2, 3]", representing an array of numbers. The resulting Python object is assigned to the variable nums. The expected result is that nums will be a list [1, 2, 3].
3. nums[2]: This line accesses the element at index 2 of the nums list. Since Python uses zero-based indexing, index 2 corresponds to the third element in the list. The expected result is 3.
4. json.dumps([5, 4, 3, 2, 1]): The json.dumps() function is used to convert a Python object into a JSON-formatted string. In this case, the Python object is the list [5, 4, 3, 2, 1]. The expected result is the JSON-formatted string "[5, 4, 3, 2, 1]".
5. me = {'first_name': 'Kenneth', 'last_name': 'Love', 'topic': 'Python'}: This line creates a Python dictionary representing information about a person. The dictionary has keys 'first_name', 'last_name', and 'topic', with corresponding values. The dictionary is assigned to the variable me.
6. str(me): This line converts the me dictionary object into a string representation using the str() function. The expected result is the string "{ 'first_name': 'Kenneth', 'last_name': 'Love', 'topic': 'Python' }".
7. json.dumps(me): Similar to step 4, this line converts the me dictionary into a JSON-formatted string. The expected result is '{"first_name": "Kenneth", "last_name": "Love", "topic": "Python"}'.
8. craig = {'first_name': 'Craig', 'last_name': 'Dennis', 'topic': 'Java'}: This line creates another Python dictionary representing information about another person. The dictionary is assigned to the variable craig.
9. with open('teachers.json', 'a') as teacherfile: json.dump([me, craig], teacherfile): This block of code opens a file named “teachers.json” in append mode ('a') and associates it with the teacherfile variable using a with statement. It then uses json.dump() to write the JSON-formatted representation of a list containing the dictionaries me and craig to the file. The json.dump() function converts the Python object into a JSON-formatted string and writes it to the file. Since the file is opened in append mode, the data will be added to the end of the file if it already exists or a new file will be created if it doesn’t exist.

The expected results of running the code are:

• nums will be [1, 2, 3].
• nums[2] will yield 3.
• json.dumps([5, 4, 3, 2, 1]) will result in the string `“[5, 4, 3, 2, 1]”

. - me will be {‘first_name’: ‘Kenneth’, ‘last_name’: ‘Love’, ‘topic’: ‘Python’}. - str(me) will produce ”{ ‘first_name’: ‘Kenneth’, ‘last_name’: ‘Love’, ‘topic’: ‘Python’ }”. - json.dumps(me) will yield ’{“first_name”: “Kenneth”, “last_name”: “Love”, “topic”: “Python”}’. - craig will be {‘first_name’: ‘Craig’, ‘last_name’: ‘Dennis’, ‘topic’: ‘Java’}. - The file "teachers.json" will be created (if it doesn't exist) or appended with the JSON-formatted representation of the list [me, craig]`.