Pandas I

The code above code stores our DataFrame object in the elections variable. Upon inspection, our elections DataFrame has 182 rows and 6 columns (Year, Candidate, Party, Popular Vote, Result, %). Each row represents a single record — in our example, a presidential candidate from some particular year. Each column represents a single attribute or feature of the record.

Using a List and Column Name(s)¶

We’ll now explore creating a DataFrame with data of our own.

Consider the following examples. The first code cell creates a DataFrame with a single column Numbers.

The second creates a DataFrame with the columns Numbers and Description. Notice how a 2D list of values is required to initialize the second DataFrame — each nested list represents a single row of data.

From a Dictionary¶

A third (and more common) way to create a DataFrame is with a dictionary. The dictionary keys represent the column names, and the dictionary values represent the column values.

Below are two ways of implementing this approach. The first is based on specifying the columns of the DataFrame, whereas the second is based on specifying the rows of the DataFrame.

From a Series¶

Earlier, we explained how a Series was synonymous to a column in a DataFrame. It follows, then, that a DataFrame is equivalent to a collection of Series, which all share the same Index.

In fact, we can initialize a DataFrame by merging two or more Series. Consider the Series s_a and s_b.

We can turn individual Series into a DataFrame using two common methods (shown below):

To merge the two Series and specify their column names, we use the following syntax:

Indices¶

On a more technical note, an index doesn’t have to be an integer, nor does it have to be unique. For example, we can set the index of the elections DataFrame to be the name of presidential candidates.

We can also select a new column and set it as the index of the DataFrame. For example, we can set the index of the elections DataFrame to represent the candidate’s party.

And, if we’d like, we can revert the index back to the default list of integers.

It is also important to note that the row labels that constitute an index don’t have to be unique. While index values can be unique and numeric, acting as a row number, they can also be named and non-unique.

Here we see unique and numeric index values.

However, here the index values are not unique.

DataFrame Attributes: Index, Columns, and Shape¶

On the other hand, column names in a DataFrame are almost always unique. Looking back to the elections dataset, it wouldn’t make sense to have two columns named "Candidate". Sometimes, you’ll want to extract these different values, in particular, the list of row and column labels.

For index/row labels, use DataFrame.index:

For column labels, use DataFrame.columns:

And for the shape of the DataFrame, we can use DataFrame.shape to get the number of rows followed by the number of columns:

Slicing in DataFrames¶

Now that we’ve learned more about DataFrames, let’s dive deeper into their capabilities.

The API (Application Programming Interface) for the DataFrame class is enormous. In this section, we’ll discuss several methods of the DataFrame API that allow us to extract subsets of data.

The simplest way to manipulate a DataFrame is to extract a subset of rows and columns, known as slicing.

Common ways we may want to extract data are grabbing:

• The first or last n rows in the DataFrame.

• Data with a certain label.

• Data at a certain position.

We will do so with four primary methods of the DataFrame class:

1. .head and .tail

2. .loc

3. .iloc

4. []

Extracting data with .head and .tail¶

The simplest scenario in which we want to extract data is when we simply want to select the first or last few rows of the DataFrame.

To extract the first n rows of a DataFrame df, we use the syntax df.head(n).

Similarly, calling df.tail(n) allows us to extract the last n rows of the DataFrame.

Label-based Extraction: Indexing with .loc¶

For the more complex task of extracting data with specific column or index labels, we can use .loc. The .loc accessor allows us to specify the labels of rows and columns we wish to extract. The labels (commonly referred to as the indices) are the bold text on the far left of a DataFrame, while the column labels are the column names found at the top of a DataFrame.

To grab data with .loc, we must specify the row and column label(s) where the data exists. The row labels are the first argument to the .loc function; the column labels are the second.

Arguments to .loc can be:

• A single value.

• A slice.

• A list.

For example, to select a single value, we can select the row labeled 0 and the column labeled Candidate from the elections DataFrame.

Keep in mind that passing in just one argument as a single value will produce a Series. Below, we’ve extracted a subset of the "Popular vote" column as a Series.

Note that if we pass "Popular vote" as a list, the output will be a DataFrame.

To select multiple rows and columns, we can use Python slice notation. Here, we select the rows from labels 0 to 3 and the columns from labels "Year" to "Popular vote". Notice that unlike Python slicing, .loc is inclusive of the right upper bound.

Suppose that instead, we want to extract all column values for the first four rows in the elections DataFrame. The shorthand : is useful for this.

We can use the same shorthand to extract all rows.

There are a couple of things we should note. Firstly, unlike conventional Python, pandas allows us to slice string values (in our example, the column labels). Secondly, slicing with .loc is inclusive. Notice how our resulting DataFrame includes every row and column between and including the slice labels we specified.

Equivalently, we can use a list to obtain multiple rows and columns in our elections DataFrame.

Lastly, we can interchange list and slicing notation.

Integer-based Extraction: Indexing with .iloc¶

Slicing with .iloc works similarly to .loc. However, .iloc uses the index positions of rows and columns rather than the labels (think to yourself: loc uses lables; iloc uses indices). The arguments to the .iloc function also behave similarly — single values, lists, indices, and any combination of these are permitted.

Let’s begin reproducing our results from above. We’ll begin by selecting the first presidential candidate in our elections DataFrame:

Notice how the first argument to both .loc and .iloc are the same. This is because the row with a label of 0 is conveniently in the $0^{\text{th}}$ (equivalently, the first position) of the elections DataFrame. Generally, this is true of any DataFrame where the row labels are incremented in ascending order from 0.

And, as before, if we were to pass in only one single value argument, our result would be a Series.

However, when we select the first four rows and columns using .iloc, we notice something.

Slicing is no longer inclusive in .iloc — it’s exclusive. In other words, the right end of a slice is not included when using .iloc. This is one of the subtleties of pandas syntax; you will get used to it with practice.

List behavior works just as expected.

And just like with .loc, we can use a colon with .iloc to extract all rows or columns.

This discussion begs the question: when should we use .loc vs. .iloc? In most cases, .loc is generally safer to use. You can imagine .iloc may return incorrect values when applied to a dataset where the ordering of data can change. However, .iloc can still be useful — for example, if you are looking at a DataFrame of sorted movie earnings and want to get the median earnings for a given year, you can use .iloc to index into the middle.

Overall, it is important to remember that:

• .loc performances label-based extraction.

• .iloc performs integer-based extraction.

Context-dependent Extraction: Indexing with []¶

The [] selection operator is the most baffling of all, yet the most commonly used. It only takes a single argument, which may be one of the following:

1. A slice of row numbers.

2. A list of column labels.

3. A single-column label.

That is, [] is context-dependent. Let’s see some examples.

A slice of row numbers¶

Say we wanted the first four rows of our elections DataFrame.

A list of column labels¶

Suppose we now want the first four columns.

A single-column label¶

Lastly, [] allows us to extract only the "Candidate" column.

The output is a Series! In this course, we’ll become very comfortable with [], especially for selecting columns. In practice, [] is much more common than .loc, especially since it is far more concise.

Parting Note¶

The pandas library is enormous and contains many useful functions. Here is a link to its documentation. We certainly don’t expect you to memorize each and every method of the library, and we will give you a reference sheet for exams.

The introductory Data 100 pandas lectures will provide a high-level view of the key data structures and methods that will form the foundation of your pandas knowledge. A goal of this course is to help you build your familiarity with the real-world programming practice of ... Googling! Answers to your questions can be found in documentation, Stack Overflow, etc. Being able to search for, read, and implement documentation is an important life skill for any data scientist.

With that, we will move on to Pandas II!