This course will continue the introduction to Python programming that started with Python Programming Essentials and Python Data Representations. We'll learn about reading, storing, and processing tabular data, which are common tasks. We will also teach you about CSV files and Python's support for reading and writing them. CSV files are a generic, plain text file format that allows you to exchange tabular data between different programs. These concepts and skills will help you to further extend your Python programming knowledge and allow you to process more complex data. By the end of the course, you will be comfortable working with tabular data in Python. This will extend your Python programming expertise, enabling you to write a wider range of scripts using Python. This course uses Python 3. While most Python programs continue to use Python 2, Python 3 is the future of the Python programming language. This course uses basic desktop Python development environments, allowing you to run Python programs directly on your computer.
CSV DictReader
Loading...
Do curso por Rice University
Python Data Analysis
263 classificações
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
Na lição
Tabular Data and CSV Files
This module will teach you the basics of CSV files and how to read them from Python programs. We will discuss the use of Python's csv module to help you access tabular data in CSV files.
Conheça os instrutores
Scott RixnerProfessor
Computer Science
Joe WarrenProfessor
Computer Science
[MUSIC]
Now that we've seen that Python has a CSV module,
let's look at some more of the capabilities of that module.
In this video, we're going to learn about the DictReader.
This is very similar to the reader that we've already seen,
except instead of parsing the rows of the CSV file
into a list of columns, it parses it into a dictionary.
Where the keys are in the name of the column, and
the values are the value of that column for the particular row.
All right, let's take a look at how this works.
So this program will use the CSV module's DictReader in order to parse a CSE file,
so let's take a look at how that works.
First we have to import csv so
that we can actually import Python's CSV module and use it.
And now we have a function that I'm calling dictparse,
this is similar to the parsing functions we've seen before, but
we're going to use the DictReader as I said, so it is slightly different.
It takes two arguments now instead of one, the first is the filename
of our CSV file and then the second is the name of a keyfield.
Well, why do we need that?
Well I want to parse this CSV file now
as a dictionary of dictionaries, instead of a list of lists.
So the outer dictionary is actually mapping
some key to the rows of the CSV file.
So what is that key?
Well each row needs to have a header column, and
the value of the header column will be the key identifying that particular row.
So if you think about the CSV files we've been looking at,
where we have the average monthly high temperatures for a bunch of cities.
The cities are the obvious columns to be the keys identifying the rows, right?
I want to know what are the average high temperatures in Houston, or Baghdad, or
Moscow, right?
I don't want to know, hey,
which rows had a 37 in February, right, that doesn't make any sense.
So the city is the obvious keyfield for that CSV file.
Now we actually need to know what the name of that column is, so
our CSV file also has to have a header row,
where the first row of the CSV file gives the names of each of the columns.
So let's take a look at how the function works,
the first thing we do is we initialize table to be an empty dictionary.
Because, as I said, we're going to have a dictionary mapping this key
value into the rows inside of the CSV file.
Right and then we open the CSV file, now notice some things here.
I explicitly used the mode rt here, which I haven't been doing,
that is the default in Python, so it doesn't really matter.
But we do know that CSV files are plaintext, and I'm trying to read them, so
this is mode that I would like to open the file.
But I've also added this extra argument here, newline equals the empty string.
Why did I do that?
Well I didn't point this out before, but
the CSV module actually handles new lines on its own.
So I do not need Python's file handling utilities to process the new lines, and
there's a good reason why I don't want them to.
And that's because I can have a new line inside the value
of a particular column in my CSV file, if that column is quoted.
So if there are quotes around it, I can have new line characters in the column.
And Python's file handling utilities can't differentiate between new lines that
are actually ending the line, and new lines that are inside some column value.
So by telling Python that the new line character is this empty string,
the file handling utilities ignore the new lines, and
leave all the new line handling up to the CSV module.
Now this doesn't matter if I don't have new lines inside of columns in my
CSV file, which is why it didn't matter whether we did this or not before.
But it also doesn't matter if you tell Python's file utilities to stop dealing
with new lines, because the CSV module will deal with them correctly.
So, it's safer to do this all the time,
even if you know that your file doesn't have new files within quoted columns.
Now, the next thing that we need to do is actually create the DictReader, and
I do this by calling csv.DictReader.
Remember that DictReader is inside the CSV module, so I need to have that csv.,
to tell Python to look inside the CSV module for DictReader.
And then I pass it the open file, csvfile, and
again I'm just going to tell it to skip initial spaces, set that to be True.
So this looks all familiar, hopefully.
Again, I can iterate through the rows of the csv reader, so
for row and csv reader, I can then add that row into the table.
Now because the table is a dictionary, I can't just append the row to the table.
Rather I need to get the key value out of the row,
and then assign the row to the table at that key.
Well notice that I'm indexing into the row with the keyfield.
The row itself, because we used a DictReader, is also a dictionary, and
that dictionary maps the names of the columns
to the value of that particular column in this row.
So the DictReader looks at the first row and
uses that as a names of the columns, and then creates dictionaries for
all other rows, mapping those names to the values at that column.
So I can look up the key value simply by indexing
the row dictionary with the keyfield.
I then use that as an index into my table to assign the row into the proper index,
so now I have the appropriate key value pair in my table dictionary.
Once I'm done, I can just return the table.
The function I used to print the table also has to change a little bit,
because the table is now a dictionary of dictionaries.
So, I want to first print out the header row, I know that the city is the name
of the first column, so I'm going to print that out.
But then I have a problem, I don't have the header row in order anywhere,
I need to actually know what are the names of columns.
So you might have noticed up at the top of this file,
I have a tuple that I've assigned to the variable MONTHS.
And this is just a tuple of the names of all the months that are basically
the names of the columns in my CSV file.
All right, so going back down here, you'll notice that I can iterate over those,
print them out in the header row.
Then I can iterate through the dictionary,
notice that I'm iterating through table.items here, so I get both the name,
and the contents of the row, I can print out the name nicely.
And then again, I have to iterate through this MONTHS dictionary,
if I don't, I'm not necessarily going to get
the information out of the row in any useful order.
I need to make sure that I get it out January, February, March, April, and
so on.
I don't want to just iterate over that inner dictionary,
because I could then get the columns in the wrong order, and
then when I print out my table it's not going to make any sense.
Also realize that the row has the keyfield in it, so the city is also in the row.
And so if I just iterated over everything,
I would also be printing out the city a second time.
So by iterating over my MONTHS tuple,
I get the columns in the order that I would like.
I can index into the row, using that month, to get the value, and
this allows me to print out my table correctly.
Now, I glossed over this, but notice because table is a dictionary,
the row's order is not preserved.
This might not print out the rows in the same order that they actually were
in the file.
This is okay only if you don't actually care what order the rows are stored in,
inside my dictionary of dictionaries.
Let's run this and see what happens.
All right, looks like it works.
Hopefully this table is somewhat recognizable now,
this is my exact same hightemp.csv file we've used before.
These are the average high temperatures per month for
ten different cities around the world.
So now we've seen that the CSV module has multiple different ways
of parsing our CSV files.
Not only can we read each row as a list of columns, we can also, if we'd like,
read each row as a dictionary that maps the name of the column to
the value of the column for that particular row.
Of course we now have the issue where the ordering of the columns is lost for
a particular row,
but usually that's not an issue unless you actually want to print the table out.
If you just want to access the columns,
you usually know the name of the column that you want.
And it might be actually easier to use the name of the column to index into the row,
rather than trying to figure out what was the numeric index into the list that you
needed to use before, okay?
Similarly, we have this outer dictionary that's lost the order of the rows in
the csv file, and that's also often not a problem.
Even when you're printing out the table,
it often doesn't matter which order the rows are in, but
if it does you need to keep track of that and figure out what to do.
But again, if you're just trying to access the rows by a particular keyfield,
then this could be more convenient.
Again you don't have to remember the order of the rows, you simply just use
the keyfield to index into that dictionary and you will have the row you want.
Then you use the column name to index into that,
to get the value at that particular column.
Now I'd also like to point out that you can mix and match here, right?
Just because I used a DictReader does not mean the table also
needed to be a dictionary, the table could have been a list, right?
And then I could have appended each row into that list, and then I would have
my two dimensional tabular data stored as a list of dictionaries.
That way the row order is preserved, okay, but
the columns can be accessed with the column names.
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2019 Coursera Inc. Todos os direitos reservados.
