Lecture 2 – Data 100, Spring 2024¶

Data 100, Spring 2024

Acknowledgments Page

A high-level overview of the pandas library to accompany Lecture 2.

In [9]:
# `pd` is the conventional alias for Pandas, as `np` is for NumPy
import pandas as pd

Series, DataFrames, and Indices¶

Series, DataFrames, and Indices are fundamental pandas data structures for storing tabular data and processing the data using vectorized operations.

Series¶

A Series is a 1-D labeled array of data. We can think of it as columnar data.

Creating a new Series object¶

Below, we create a Series object and will look into its two components: 1) values and 2) index.

In [10]:
s = pd.Series(["welcome", "to", "data 100"])

s
Out[10]:
0     welcome
1          to
2    data 100
dtype: object
In [11]:
s.values
Out[11]:
array(['welcome', 'to', 'data 100'], dtype=object)
In [12]:
s.index
Out[12]:
RangeIndex(start=0, stop=3, step=1)

In the example above, pandas automatically generated an Index of integer labels. We can also create a Series object by providing a custom Index.

In [13]:
s = pd.Series([-1, 10, 2], index = ["a", "b", "c"])
s
Out[13]:
a    -1
b    10
c     2
dtype: int64
In [14]:
s.values
Out[14]:
array([-1, 10,  2])
In [15]:
s.index
Out[15]:
Index(['a', 'b', 'c'], dtype='object')

After it has been created, we can reassign the Index of a Series to a new Index.

In [16]:
s.index = ["first", "second", "third"]
s
Out[16]:
first     -1
second    10
third      2
dtype: int64

Selection in Series¶

We can select a single value or a set of values in a Series using:

  • A single label
  • A list of labels
  • A filtering condition
In [17]:
s = pd.Series([4, -2, 0, 6], index = ["a", "b", "c", "d"])
s
Out[17]:
a    4
b   -2
c    0
d    6
dtype: int64

Selection using one or more label(s)

In [18]:
# Selection using a single label
# Notice how the return value is a single array element
s["a"]
Out[18]:
4
In [19]:
# Selection using a list of labels
# Notice how the return value is another Series
s[["a", "c"]]
Out[19]:
a    4
c    0
dtype: int64

Selection using a filter condition

In [20]:
# Filter condition: select all elements greater than 0
s>0
Out[20]:
a     True
b    False
c    False
d     True
dtype: bool
In [21]:
# Use the Boolean filter to select data from the original Series
s[s>0]
Out[21]:
a    4
d    6
dtype: int64

DataFrame¶

A DataFrame is a 2-D tabular data structure with both row and column labels. In this lecture, we will see how a DataFrame can be created from scratch or loaded from a file.

Creating a new DataFrame object¶

We can also create a DataFrame in a variety of ways. Here, we cover the following:

  1. From a CSV file
  2. Using a list and column names
  3. From a dictionary
  4. From a Series

Creating a DataFrame from a CSV file¶

For loading data into a DataFrame, pandas has a number of very useful file reading tools. We'll be using read_csv today to load data from a CSV file into a DataFrame object.

In [22]:
elections = pd.read_csv("data/elections.csv")
elections
Out[22]:
Year Candidate Party Popular vote Result %
0 1824 Andrew Jackson Democratic-Republican 151271 loss 57.210122
1 1824 John Quincy Adams Democratic-Republican 113142 win 42.789878
2 1828 Andrew Jackson Democratic 642806 win 56.203927
3 1828 John Quincy Adams National Republican 500897 loss 43.796073
4 1832 Andrew Jackson Democratic 702735 win 54.574789
... ... ... ... ... ... ...
177 2016 Jill Stein Green 1457226 loss 1.073699
178 2020 Joseph Biden Democratic 81268924 win 51.311515
179 2020 Donald Trump Republican 74216154 loss 46.858542
180 2020 Jo Jorgensen Libertarian 1865724 loss 1.177979
181 2020 Howard Hawkins Green 405035 loss 0.255731

182 rows × 6 columns

By passing a column to the index_col attribute, the Index can be defined at the initialization.

In [23]:
elections = pd.read_csv("data/elections.csv", index_col = "Candidate")
elections
Out[23]:
Candidate Party Popular vote Result %
Year
1824 Andrew Jackson Democratic-Republican 151271 loss 57.210122
1824 John Quincy Adams Democratic-Republican 113142 win 42.789878
1828 Andrew Jackson Democratic 642806 win 56.203927
1828 John Quincy Adams National Republican 500897 loss 43.796073
1832 Andrew Jackson Democratic 702735 win 54.574789
... ... ... ... ... ...
2016 Jill Stein Green 1457226 loss 1.073699
2020 Joseph Biden Democratic 81268924 win 51.311515
2020 Donald Trump Republican 74216154 loss 46.858542
2020 Jo Jorgensen Libertarian 1865724 loss 1.177979
2020 Howard Hawkins Green 405035 loss 0.255731

182 rows × 5 columns

Creating a DataFrame using a list and column names¶

In [24]:
# Creating a single-column DataFrame using a list
df_list_1 = pd.DataFrame([1, 2, 3], 
                         columns = ["Number"])
display(df_list_1)
Number
0 1
1 2
2 3
In [25]:
# Creating a multi-column DataFrame using a list of lists
df_list_2 = pd.DataFrame([[1, "one"], [2, "two"]], 
                         columns = ["Number", "Description"])
df_list_2
Out[25]:
Number Description
0 1 one
1 2 two

Creating a DataFrame from a dictionary¶

In [26]:
# Creating a DataFrame from a dictionary of columns
df_dict_1 = pd.DataFrame({"Fruit":["Strawberry", "Orange"], 
                          "Price":[5.49, 3.99]})
df_dict_1
Out[26]:
Fruit Price
0 Strawberry 5.49
1 Orange 3.99
In [27]:
# Creating a DataFrame from a list of row dictionaries
df_dict_2 = pd.DataFrame([{"Fruit":"Strawberry", "Price":5.49}, 
                          {"Fruit":"Orange", "Price":3.99}])
df_dict_2
Out[27]:
Fruit Price
0 Strawberry 5.49
1 Orange 3.99

Creating a DataFrame from a Series¶

In [28]:
# In the examples below, we create a DataFrame from a Series

s_a = pd.Series(["a1", "a2", "a3"], index = ["r1", "r2", "r3"])
s_b = pd.Series(["b1", "b2", "b3"], index = ["r1", "r2", "r3"])
In [29]:
# Passing Series objects for columns
df_ser = pd.DataFrame({"A-column":s_a, "B-column":s_b})
df_ser
Out[29]:
A-column B-column
r1 a1 b1
r2 a2 b2
r3 a3 b3
In [30]:
# Passing a Series to the DataFrame constructor to make a one-column dataframe
df_ser = pd.DataFrame(s_a)
df_ser
Out[30]:
0
r1 a1
r2 a2
r3 a3
In [31]:
# Using to_frame() to convert a Series to DataFrame
ser_to_df = s_a.to_frame()
ser_to_df
Out[31]:
0
r1 a1
r2 a2
r3 a3
In [32]:
# Creating a DataFrame from a CSV file and specifying the Index column
elections = pd.read_csv("data/elections.csv", index_col = "Candidate")
elections.head(5) # Using `.head` shows only the first 5 rows to save space
Out[32]:
Year Party Popular vote Result %
Candidate
Andrew Jackson 1824 Democratic-Republican 151271 loss 57.210122
John Quincy Adams 1824 Democratic-Republican 113142 win 42.789878
Andrew Jackson 1828 Democratic 642806 win 56.203927
John Quincy Adams 1828 National Republican 500897 loss 43.796073
Andrew Jackson 1832 Democratic 702735 win 54.574789
In [33]:
elections.reset_index(inplace = True) # Need to reset the index to keep 'Candidate' as one of the DataFrane Columns
elections.set_index("Party", inplace=True) # This sets the index to the "Candidate" column
elections
Out[33]:
Candidate Year Popular vote Result %
Party
Democratic-Republican Andrew Jackson 1824 151271 loss 57.210122
Democratic-Republican John Quincy Adams 1824 113142 win 42.789878
Democratic Andrew Jackson 1828 642806 win 56.203927
National Republican John Quincy Adams 1828 500897 loss 43.796073
Democratic Andrew Jackson 1832 702735 win 54.574789
... ... ... ... ... ...
Green Jill Stein 2016 1457226 loss 1.073699
Democratic Joseph Biden 2020 81268924 win 51.311515
Republican Donald Trump 2020 74216154 loss 46.858542
Libertarian Jo Jorgensen 2020 1865724 loss 1.177979
Green Howard Hawkins 2020 405035 loss 0.255731

182 rows × 5 columns

DataFrame attributes: index, columns, and shape¶

In [34]:
elections.index
Out[34]:
Index(['Democratic-Republican', 'Democratic-Republican', 'Democratic',
       'National Republican', 'Democratic', 'National Republican',
       'Anti-Masonic', 'Whig', 'Democratic', 'Whig',
       ...
       'Constitution', 'Republican', 'Independent', 'Libertarian',
       'Democratic', 'Green', 'Democratic', 'Republican', 'Libertarian',
       'Green'],
      dtype='object', name='Party', length=182)
In [35]:
elections.columns
Out[35]:
Index(['Candidate', 'Year', 'Popular vote', 'Result', '%'], dtype='object')

The Index column can be set to the default list of integers by calling reset_index() on a DataFrame.

In [36]:
elections.reset_index(inplace=True) # Revert the index back to its default numeric labeling
elections
Out[36]:
Party Candidate Year Popular vote Result %
0 Democratic-Republican Andrew Jackson 1824 151271 loss 57.210122
1 Democratic-Republican John Quincy Adams 1824 113142 win 42.789878
2 Democratic Andrew Jackson 1828 642806 win 56.203927
3 National Republican John Quincy Adams 1828 500897 loss 43.796073
4 Democratic Andrew Jackson 1832 702735 win 54.574789
... ... ... ... ... ... ...
177 Green Jill Stein 2016 1457226 loss 1.073699
178 Democratic Joseph Biden 2020 81268924 win 51.311515
179 Republican Donald Trump 2020 74216154 loss 46.858542
180 Libertarian Jo Jorgensen 2020 1865724 loss 1.177979
181 Green Howard Hawkins 2020 405035 loss 0.255731

182 rows × 6 columns

In [37]:
elections.shape
Out[37]:
(182, 6)

Slicing in DataFrames¶

We can use .head to return only a few rows of a dataframe.

In [38]:
# Loading DataFrame again to keep the original ordering of columns
elections = pd.read_csv("data/elections.csv")

elections.head() # By default, calling .head with no argument will show the first 5 rows
Out[38]:
Year Candidate Party Popular vote Result %
0 1824 Andrew Jackson Democratic-Republican 151271 loss 57.210122
1 1824 John Quincy Adams Democratic-Republican 113142 win 42.789878
2 1828 Andrew Jackson Democratic 642806 win 56.203927
3 1828 John Quincy Adams National Republican 500897 loss 43.796073
4 1832 Andrew Jackson Democratic 702735 win 54.574789
In [39]:
elections.head(3)
Out[39]:
Year Candidate Party Popular vote Result %
0 1824 Andrew Jackson Democratic-Republican 151271 loss 57.210122
1 1824 John Quincy Adams Democratic-Republican 113142 win 42.789878
2 1828 Andrew Jackson Democratic 642806 win 56.203927

We can also use .tail to get the last so many rows.

In [40]:
elections.tail(5)
Out[40]:
Year Candidate Party Popular vote Result %
177 2016 Jill Stein Green 1457226 loss 1.073699
178 2020 Joseph Biden Democratic 81268924 win 51.311515
179 2020 Donald Trump Republican 74216154 loss 46.858542
180 2020 Jo Jorgensen Libertarian 1865724 loss 1.177979
181 2020 Howard Hawkins Green 405035 loss 0.255731

Label-Based Extraction Usingloc¶

Arguments to .loc can be:

  1. A list.
  2. A slice (syntax is inclusive of the right-hand side of the slice).
  3. A single value.

loc selects items by row and column label.

In [41]:
# Selection by a list
elections.loc[[87, 25, 179], ["Year", "Candidate", "Result"]]
Out[41]:
Year Candidate Result
87 1932 Herbert Hoover loss
25 1860 John C. Breckinridge loss
179 2020 Donald Trump loss
In [42]:
# Selection by a list and a slice of columns
elections.loc[[87, 25, 179], "Popular vote":"%"]
Out[42]:
Popular vote Result %
87 15761254 loss 39.830594
25 848019 loss 18.138998
179 74216154 loss 46.858542
In [46]:
# Extracting all rows using a colon
elections.loc[:, ["Year", "Candidate", "Result"]]
Out[46]:
Year Candidate Result
0 1824 Andrew Jackson loss
1 1824 John Quincy Adams win
2 1828 Andrew Jackson win
3 1828 John Quincy Adams loss
4 1832 Andrew Jackson win
... ... ... ...
177 2016 Jill Stein loss
178 2020 Joseph Biden win
179 2020 Donald Trump loss
180 2020 Jo Jorgensen loss
181 2020 Howard Hawkins loss

182 rows × 3 columns

In [51]:
# Extracting all columns using a colon
elections.loc[[87, 25, 179], :]
Out[51]:
Year Candidate Party Popular vote Result %
87 1932 Herbert Hoover Republican 15761254 loss 39.830594
25 1860 John C. Breckinridge Southern Democratic 848019 loss 18.138998
179 2020 Donald Trump Republican 74216154 loss 46.858542
In [52]:
# Selection by a list and a single-column label
elections.loc[[87, 25, 179], "Popular vote"]
Out[52]:
87     15761254
25       848019
179    74216154
Name: Popular vote, dtype: int64
In [53]:
# Note that if we pass "Popular vote" in a list, the output will be a DataFrame
elections.loc[[87, 25, 179], ["Popular vote"]]
Out[53]:
Popular vote
87 15761254
25 848019
179 74216154
In [54]:
# Selection by a row label and a column label
elections.loc[0, "Candidate"]
Out[54]:
'Andrew Jackson'

Integer-Based Extraction Using iloc¶

iloc selects items by row and column integer position.

Arguments to .iloc can be:

  1. A list.
  2. A slice (syntax is exclusive of the right hand side of the slice).
  3. A single value.
In [55]:
# Select the rows at positions 1, 2, and 3.
# Select the columns at positions 0, 1, and 2.
# Remember that Python indexing begins at position 0!
elections.iloc[[1, 2, 3], [0, 1, 2]]
Out[55]:
Year Candidate Party
1 1824 John Quincy Adams Democratic-Republican
2 1828 Andrew Jackson Democratic
3 1828 John Quincy Adams National Republican
In [56]:
# Index-based extraction using a list of rows and a slice of column indices
elections.iloc[[1, 2, 3], 0:3]
Out[56]:
Year Candidate Party
1 1824 John Quincy Adams Democratic-Republican
2 1828 Andrew Jackson Democratic
3 1828 John Quincy Adams National Republican
In [57]:
# Selecting all rows using a colon
elections.iloc[:, 0:3]
Out[57]:
Year Candidate Party
0 1824 Andrew Jackson Democratic-Republican
1 1824 John Quincy Adams Democratic-Republican
2 1828 Andrew Jackson Democratic
3 1828 John Quincy Adams National Republican
4 1832 Andrew Jackson Democratic
... ... ... ...
177 2016 Jill Stein Green
178 2020 Joseph Biden Democratic
179 2020 Donald Trump Republican
180 2020 Jo Jorgensen Libertarian
181 2020 Howard Hawkins Green

182 rows × 3 columns

In [58]:
elections.iloc[[1, 2, 3], 1]
Out[58]:
1    John Quincy Adams
2       Andrew Jackson
3    John Quincy Adams
Name: Candidate, dtype: object
In [59]:
# Extracting the value at row 0 and the second column
elections.iloc[0,1]
Out[59]:
'Andrew Jackson'

Context-dependent Extraction using []¶

We could technically do anything we want using loc or iloc. However, in practice, the [] operator is often used instead to yield more concise code.

[] is a bit trickier to understand than loc or iloc, but it achieves essentially the same functionality. The difference is that [] is context-dependent.

[] only takes one argument, which may be:

  1. A slice of row integers.
  2. A list of column labels.
  3. A single column label.

If we provide a slice of row numbers, we get the numbered rows.

In [60]:
elections[3:7]
Out[60]:
Year Candidate Party Popular vote Result %
3 1828 John Quincy Adams National Republican 500897 loss 43.796073
4 1832 Andrew Jackson Democratic 702735 win 54.574789
5 1832 Henry Clay National Republican 484205 loss 37.603628
6 1832 William Wirt Anti-Masonic 100715 loss 7.821583

If we provide a list of column names, we get the listed columns.

In [61]:
elections[["Year", "Candidate", "Result"]]
Out[61]:
Year Candidate Result
0 1824 Andrew Jackson loss
1 1824 John Quincy Adams win
2 1828 Andrew Jackson win
3 1828 John Quincy Adams loss
4 1832 Andrew Jackson win
... ... ... ...
177 2016 Jill Stein loss
178 2020 Joseph Biden win
179 2020 Donald Trump loss
180 2020 Jo Jorgensen loss
181 2020 Howard Hawkins loss

182 rows × 3 columns

And if we provide a single column name we get back just that column, stored as a Series.

In [62]:
elections["Candidate"]
Out[62]:
0         Andrew Jackson
1      John Quincy Adams
2         Andrew Jackson
3      John Quincy Adams
4         Andrew Jackson
             ...        
177           Jill Stein
178         Joseph Biden
179         Donald Trump
180         Jo Jorgensen
181       Howard Hawkins
Name: Candidate, Length: 182, dtype: object

Slido Exercises¶

In [63]:
example = pd.Series([4, 5, 6], index=["one", "two", "three"])
example[example > 4].values
Out[63]:
array([5, 6])
In [64]:
df = pd.DataFrame({"c1":[1, 2, 3, 4], "c2":[2, 4, 6, 8]})
df.columns
Out[64]:
Index(['c1', 'c2'], dtype='object')