Published

2025-03-31

Pandas Data Frames

Justin Post

Pandas DataFrames are super useful 2D data structures!
- Each column is a Series object
- Each column can be of differing types (just like most common data sets!)

Note: These types of webpages are built from Jupyter notebooks (.ipynb files). You can access your own versions of them by clicking here. It is highly recommended that you go through and run the notebooks yourself, modifying and rerunning things where you’d like!

Creating a `DataFrame`

Most of the time we’ll read data from a raw file directly into a DataFrame
However, you can create one with the pd.DataFrame() function

import pandas as pd
import numpy as np

Creating a Data Frame from Lists

zip() lists of the same length together
specify columns via columns = list of appropriate length
specify row names via index = list of appropriate length (if you want!)

#populate some lists, each of equal length
name = ['Alice', 'Bob','Charlie','Dave','Eve','Francesca','Greg']
age = [20, 21, 22, 23, 22, 21, 22]
major = ['Statistics', 'History', 'Chemistry', 'English', 'Math', 'Civil Engineering','Statistics']

#create the data frame using zip()
my_df = pd.DataFrame(zip(name, age, major), columns = ["name", "age", "major"])
my_df

	name	age	major
0	Alice	20	Statistics
1	Bob	21	History
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math
5	Francesca	21	Civil Engineering
6	Greg	22	Statistics

Creating a Data Frame from a Dictionary

The pd.DataFrame() function can create DataFrames from many objects
For a dictionary (dict object), the keys become the column names (values must be of the same length)

people = {'Name': ['Alice', 'Bob','Charlie','Dave','Eve','Francesca','Greg'],
          'Age': [20, 21, 22, 23, 22, 21, 22],
          'Major': ['Statistics', 'History', 'Chemistry', 'English', 'Math', 'Civil Engineering','Statistics'],
         }
people

{'Name': ['Alice', 'Bob', 'Charlie', 'Dave', 'Eve', 'Francesca', 'Greg'],
 'Age': [20, 21, 22, 23, 22, 21, 22],
 'Major': ['Statistics',
  'History',
  'Chemistry',
  'English',
  'Math',
  'Civil Engineering',
  'Statistics']}

my_df = pd.DataFrame(people)
my_df

	Name	Age	Major
0	Alice	20	Statistics
1	Bob	21	History
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math
5	Francesca	21	Civil Engineering
6	Greg	22	Statistics

Creating a Data Frame from a `NumPy` Array

If you have a 2D numpy array, the conversion to a DataFrame object is natural
You can specify the column names with columns = and the indices with index =

my_array = np.random.random((5,3))
print(my_array.shape)
my_array

(5, 3)

array([[0.44601505, 0.15726038, 0.63256689],
       [0.74871631, 0.35006141, 0.58570382],
       [0.14346733, 0.22706604, 0.02253265],
       [0.57983249, 0.60743321, 0.88242121],
       [0.20877059, 0.75132726, 0.04447515]])

my_df2 = pd.DataFrame(my_array, columns=["1st", "2nd", "3rd"], index=["a", "b", "c", "d", "e"])
my_df2

	1st	2nd	3rd
a	0.446015	0.157260	0.632567
b	0.748716	0.350061	0.585704
c	0.143467	0.227066	0.022533
d	0.579832	0.607433	0.882421
e	0.208771	0.751327	0.044475

Indexing a Data Frame

Indexing Columns with `[]`

DataFrames have a .columns attribute

my_df2.columns

Index(['1st', '2nd', '3rd'], dtype='object')

We can access the columns using a string of the column names and ‘selection brackets’

my_df2["1st"]

	1st
a	0.446015
b	0.748716
c	0.143467
d	0.579832
e	0.208771

dtype: float64

Note that what gets returned is just a Series!

type(my_df2["1st"])

pandas.core.series.Series
def __init__(data=None, index=None, dtype: Dtype | None=None, name=None, copy: bool | None=None, fastpath: bool | lib.NoDefault=lib.no_default) -> None

/usr/local/lib/python3.10/dist-packages/pandas/core/series.pyOne-dimensional ndarray with axis labels (including time series).

Labels need not be unique but must be a hashable type. The object
supports both integer- and label-based indexing and provides a host of
methods for performing operations involving the index. Statistical
methods from ndarray have been overridden to automatically exclude
missing data (currently represented as NaN).

Operations between Series (+, -, /, \*, \*\*) align values based on their
associated index values-- they need not be the same length. The result
index will be the sorted union of the two indexes.

Parameters
----------
data : array-like, Iterable, dict, or scalar value
    Contains data stored in Series. If data is a dict, argument order is
    maintained.
index : array-like or Index (1d)
    Values must be hashable and have the same length as `data`.
    Non-unique index values are allowed. Will default to
    RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like
    and index is None, then the keys in the data are used as the index. If the
    index is not None, the resulting Series is reindexed with the index values.
dtype : str, numpy.dtype, or ExtensionDtype, optional
    Data type for the output Series. If not specified, this will be
    inferred from `data`.
    See the :ref:`user guide <basics.dtypes>` for more usages.
name : Hashable, default None
    The name to give to the Series.
copy : bool, default False
    Copy input data. Only affects Series or 1d ndarray input. See examples.

Notes
-----
Please reference the :ref:`User Guide <basics.series>` for more information.

Examples
--------
Constructing Series from a dictionary with an Index specified

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> ser = pd.Series(data=d, index=['a', 'b', 'c'])
>>> ser
a   1
b   2
c   3
dtype: int64

The keys of the dictionary match with the Index values, hence the Index
values have no effect.

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> ser = pd.Series(data=d, index=['x', 'y', 'z'])
>>> ser
x   NaN
y   NaN
z   NaN
dtype: float64

Note that the Index is first build with the keys from the dictionary.
After this the Series is reindexed with the given Index values, hence we
get all NaN as a result.

Constructing Series from a list with `copy=False`.

>>> r = [1, 2]
>>> ser = pd.Series(r, copy=False)
>>> ser.iloc[0] = 999
>>> r
[1, 2]
>>> ser
0    999
1      2
dtype: int64

Due to input data type the Series has a `copy` of
the original data even though `copy=False`, so
the data is unchanged.

Constructing Series from a 1d ndarray with `copy=False`.

>>> r = np.array([1, 2])
>>> ser = pd.Series(r, copy=False)
>>> ser.iloc[0] = 999
>>> r
array([999,   2])
>>> ser
0    999
1      2
dtype: int64

Due to input data type the Series has a `view` on
the original data, so
the data is changed as well.

We can also return a column using the attribute syntax with the column name (a period at the end of the object followed by the column name)

my_df.Major

	Major
0	Statistics
1	History
2	Chemistry
3	English
4	Math
5	Civil Engineering
6	Statistics

dtype: object

type(my_df.Major) #again a Series!

pandas.core.series.Series
def __init__(data=None, index=None, dtype: Dtype | None=None, name=None, copy: bool | None=None, fastpath: bool | lib.NoDefault=lib.no_default) -> None

/usr/local/lib/python3.10/dist-packages/pandas/core/series.pyOne-dimensional ndarray with axis labels (including time series).

Labels need not be unique but must be a hashable type. The object
supports both integer- and label-based indexing and provides a host of
methods for performing operations involving the index. Statistical
methods from ndarray have been overridden to automatically exclude
missing data (currently represented as NaN).

Operations between Series (+, -, /, \*, \*\*) align values based on their
associated index values-- they need not be the same length. The result
index will be the sorted union of the two indexes.

Parameters
----------
data : array-like, Iterable, dict, or scalar value
    Contains data stored in Series. If data is a dict, argument order is
    maintained.
index : array-like or Index (1d)
    Values must be hashable and have the same length as `data`.
    Non-unique index values are allowed. Will default to
    RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like
    and index is None, then the keys in the data are used as the index. If the
    index is not None, the resulting Series is reindexed with the index values.
dtype : str, numpy.dtype, or ExtensionDtype, optional
    Data type for the output Series. If not specified, this will be
    inferred from `data`.
    See the :ref:`user guide <basics.dtypes>` for more usages.
name : Hashable, default None
    The name to give to the Series.
copy : bool, default False
    Copy input data. Only affects Series or 1d ndarray input. See examples.

Notes
-----
Please reference the :ref:`User Guide <basics.series>` for more information.

Examples
--------
Constructing Series from a dictionary with an Index specified

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> ser = pd.Series(data=d, index=['a', 'b', 'c'])
>>> ser
a   1
b   2
c   3
dtype: int64

The keys of the dictionary match with the Index values, hence the Index
values have no effect.

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> ser = pd.Series(data=d, index=['x', 'y', 'z'])
>>> ser
x   NaN
y   NaN
z   NaN
dtype: float64

Note that the Index is first build with the keys from the dictionary.
After this the Series is reindexed with the given Index values, hence we
get all NaN as a result.

Constructing Series from a list with `copy=False`.

>>> r = [1, 2]
>>> ser = pd.Series(r, copy=False)
>>> ser.iloc[0] = 999
>>> r
[1, 2]
>>> ser
0    999
1      2
dtype: int64

Due to input data type the Series has a `copy` of
the original data even though `copy=False`, so
the data is unchanged.

Constructing Series from a 1d ndarray with `copy=False`.

>>> r = np.array([1, 2])
>>> ser = pd.Series(r, copy=False)
>>> ser.iloc[0] = 999
>>> r
array([999,   2])
>>> ser
0    999
1      2
dtype: int64

Due to input data type the Series has a `view` on
the original data, so
the data is changed as well.

Returning more than one column is easy
You can give a list of the column names you want to the selection brackets

my_df[['Name', 'Age']]

	Name	Age
0	Alice	20
1	Bob	21
2	Charlie	22
3	Dave	23
4	Eve	22
5	Francesca	21
6	Greg	22

Note you can’t use slicing for columns using just [] (we’ll need to us .iloc[] or .loc[], which we cover in a moment)
If you try to index with slicing you get back appropriate rows (see below)

Indexing Rows by Slicing with `[]`

Similarly, you can index the rows using [] if you use a slice or a boolean array of appropriate length

my_df

	Name	Age	Major
0	Alice	20	Statistics
1	Bob	21	History
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math
5	Francesca	21	Civil Engineering
6	Greg	22	Statistics

my_df[3:5] #get the 3rd and 4th rows

	Name	Age	Major
3	Dave	23	English
4	Eve	22	Math

my_df2

	1st	2nd	3rd
a	0.446015	0.157260	0.632567
b	0.748716	0.350061	0.585704
c	0.143467	0.227066	0.022533
d	0.579832	0.607433	0.882421
e	0.208771	0.751327	0.044475

my_df2[1:5] #get the 2nd through 5th rows (counting starts at 0!)

	1st	2nd	3rd
b	0.748716	0.350061	0.585704
c	0.143467	0.227066	0.022533
d	0.579832	0.607433	0.882421
e	0.208771	0.751327	0.044475

Oddly, you can’t return a single row with just a number
You can return it using slicing (recall : usually doesn’t return the last value)

my_df2[1] #throws an error

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py in get_loc(self, key)
   3804         try:
-> 3805             return self._engine.get_loc(casted_key)
   3806         except KeyError as err:

index.pyx in pandas._libs.index.IndexEngine.get_loc()

index.pyx in pandas._libs.index.IndexEngine.get_loc()

pandas/_libs/hashtable_class_helper.pxi in pandas._libs.hashtable.PyObjectHashTable.get_item()

pandas/_libs/hashtable_class_helper.pxi in pandas._libs.hashtable.PyObjectHashTable.get_item()

KeyError: 1

The above exception was the direct cause of the following exception:

KeyError                                  Traceback (most recent call last)
<ipython-input-23-90bcbc95bda4> in <cell line: 1>()
----> 1 my_df2[1] #throws an error

/usr/local/lib/python3.10/dist-packages/pandas/core/frame.py in __getitem__(self, key)
   4100             if self.columns.nlevels > 1:
   4101                 return self._getitem_multilevel(key)
-> 4102             indexer = self.columns.get_loc(key)
   4103             if is_integer(indexer):
   4104                 indexer = [indexer]

/usr/local/lib/python3.10/dist-packages/pandas/core/indexes/base.py in get_loc(self, key)
   3810             ):
   3811                 raise InvalidIndexError(key)
-> 3812             raise KeyError(key) from err
   3813         except TypeError:
   3814             # If we have a listlike key, _check_indexing_error will raise

KeyError: 1

my_df2[1:2] #return just one row

	1st	2nd	3rd
b	0.748716	0.350061	0.585704

Indexing Rows Using a Boolean Array with `[]`

Often we use a Boolean object to subset the rows (rows with a True get returned, False do not)
This comes up when we use a condition found using a variable from our data frame to do the subsetting

my_df['Name'] == 'Alice' #create a boolean array

	Name
0	True
1	False
2	False
3	False
4	False
5	False
6	False

dtype: bool

my_df[my_df['Name'] == 'Alice'] #return just the True rows

	Name	Age	Major
0	Alice	20	Statistics

my_df[my_df['Age'] > 21] #return only rows that match

	Name	Age	Major
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math
6	Greg	22	Statistics

Compound Logicals

All the standard compound logical operators exist
& (and), | (or), ~ (not), ^ (xor - exclusive or)

First, two boolean vectors:

(my_df['Name'] == 'Alice')

	Name
0	True
1	False
2	False
3	False
4	False
5	False
6	False

dtype: bool

(my_df['Name'] == 'Greg')

	Name
0	False
1	False
2	False
3	False
4	False
5	False
6	True

dtype: bool

Get either/or for these two booleans

(my_df['Name'] == 'Alice') | (my_df['Name'] == 'Greg')

	Name
0	True
1	False
2	False
3	False
4	False
5	False
6	True

dtype: bool

Now we can subset the data based on this compound condition!

my_df[(my_df['Name'] == 'Alice') | (my_df['Name'] == 'Greg')]

	Name	Age	Major
0	Alice	20	Statistics
6	Greg	22	Statistics

When doing lots of logicals, you want to be careful and use () to keep things straight!

my_df[((my_df['Name'] == 'Alice') | (my_df['Name'] == 'Greg')) & (my_df['Age'] > 21)]

	Name	Age	Major
6	Greg	22	Statistics

Indexing a Data Frame’s Rows & Columns

To index both rows and columns at once, we use the .iloc[] and .loc[] methods

Indexing Rows with `.iloc[]`

Can access rows by their integer location using .iloc[]

my_df.iloc[0]

	0
Name	Alice
Age	20
Major	Statistics

dtype: object

type(my_df.iloc[1]) #Again a Series is returned

pandas.core.series.Series
def __init__(data=None, index=None, dtype: Dtype | None=None, name=None, copy: bool | None=None, fastpath: bool | lib.NoDefault=lib.no_default) -> None

/usr/local/lib/python3.10/dist-packages/pandas/core/series.pyOne-dimensional ndarray with axis labels (including time series).

Labels need not be unique but must be a hashable type. The object
supports both integer- and label-based indexing and provides a host of
methods for performing operations involving the index. Statistical
methods from ndarray have been overridden to automatically exclude
missing data (currently represented as NaN).

Operations between Series (+, -, /, \*, \*\*) align values based on their
associated index values-- they need not be the same length. The result
index will be the sorted union of the two indexes.

Parameters
----------
data : array-like, Iterable, dict, or scalar value
    Contains data stored in Series. If data is a dict, argument order is
    maintained.
index : array-like or Index (1d)
    Values must be hashable and have the same length as `data`.
    Non-unique index values are allowed. Will default to
    RangeIndex (0, 1, 2, ..., n) if not provided. If data is dict-like
    and index is None, then the keys in the data are used as the index. If the
    index is not None, the resulting Series is reindexed with the index values.
dtype : str, numpy.dtype, or ExtensionDtype, optional
    Data type for the output Series. If not specified, this will be
    inferred from `data`.
    See the :ref:`user guide <basics.dtypes>` for more usages.
name : Hashable, default None
    The name to give to the Series.
copy : bool, default False
    Copy input data. Only affects Series or 1d ndarray input. See examples.

Notes
-----
Please reference the :ref:`User Guide <basics.series>` for more information.

Examples
--------
Constructing Series from a dictionary with an Index specified

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> ser = pd.Series(data=d, index=['a', 'b', 'c'])
>>> ser
a   1
b   2
c   3
dtype: int64

The keys of the dictionary match with the Index values, hence the Index
values have no effect.

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> ser = pd.Series(data=d, index=['x', 'y', 'z'])
>>> ser
x   NaN
y   NaN
z   NaN
dtype: float64

Note that the Index is first build with the keys from the dictionary.
After this the Series is reindexed with the given Index values, hence we
get all NaN as a result.

Constructing Series from a list with `copy=False`.

>>> r = [1, 2]
>>> ser = pd.Series(r, copy=False)
>>> ser.iloc[0] = 999
>>> r
[1, 2]
>>> ser
0    999
1      2
dtype: int64

Due to input data type the Series has a `copy` of
the original data even though `copy=False`, so
the data is unchanged.

Constructing Series from a 1d ndarray with `copy=False`.

>>> r = np.array([1, 2])
>>> ser = pd.Series(r, copy=False)
>>> ser.iloc[0] = 999
>>> r
array([999,   2])
>>> ser
0    999
1      2
dtype: int64

Due to input data type the Series has a `view` on
the original data, so
the data is changed as well.

The row is return as a Series with the data type being as broad as it needs to be. Here it is returned with a data type of object (used for storing mixed data types)

my_df.iloc[1]

	1
Name	Bob
Age	21
Major	History

dtype: object

With our other data object, all elements in a row are floats so that is the data type of the series that is returned

my_df2.iloc[1].dtype

dtype('float64')

You can return more than one row by passing a list (or similar type object, such as a range() call) of the numeric indices you want

my_df.iloc[[0,1]]

	Name	Age	Major
0	Alice	20	Statistics
1	Bob	21	History

my_df.iloc[2:5] #note this doesn't include the last value!

	Name	Age	Major
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math

my_df.iloc[range(0,3)] #range doesn't include the last value either!

	Name	Age	Major
0	Alice	20	Statistics
1	Bob	21	History
2	Charlie	22	Chemistry

`.iloc[]` for Returning Rows and Columns

.iloc[] allows for subsetting of columns by location too!
Simply add a , to get the 2nd dimension (similar to subsetting a numpy array)

my_df.iloc[[0,1], [0, 2]] #rows [0,1], columns [0,2]

	Name	Major
0	Alice	Statistics
1	Bob	History

my_df.iloc[3:6, 0:2] #slicing doesn't include either last value

	Name	Age
3	Dave	23
4	Eve	22
5	Francesca	21

Indexing Rows with `.loc[]`

.loc[] is similar to .iloc[] but it allows for subsetting based on labels or boolean arrays
Slicing has a slightly different behavior! The last value is included for .loc[]. How awesomely confusing and annoying!

my_df

	Name	Age	Major
0	Alice	20	Statistics
1	Bob	21	History
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math
5	Francesca	21	Civil Engineering
6	Greg	22	Statistics

my_df.loc[0] #0 is interpreted as a label, which exists for my_df

	0
Name	Alice
Age	20
Major	Statistics

dtype: object

my_df2

	1st	2nd	3rd
a	0.446015	0.157260	0.632567
b	0.748716	0.350061	0.585704
c	0.143467	0.227066	0.022533
d	0.579832	0.607433	0.882421
e	0.208771	0.751327	0.044475

my_df2.loc["b"]

	b
1st	0.748716
2nd	0.350061
3rd	0.585704

dtype: float64

You can use slicing

my_df.loc[2:5] #note this includes the last value! (again interpreted as labels)

	Name	Age	Major
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math
5	Francesca	21	Civil Engineering

my_df2.loc["b":"e"] #includes the last value!

	1st	2nd	3rd
b	0.748716	0.350061	0.585704
c	0.143467	0.227066	0.022533
d	0.579832	0.607433	0.882421
e	0.208771	0.751327	0.044475

`.loc[]` for Returning Rows and Columns

Just like with .iloc[] you can return both columns and rows if you put in a , for the dimensions (rows, columns)

my_df.loc[:3, ['Name', "Major"]]

	Name	Major
0	Alice	Statistics
1	Bob	History
2	Charlie	Chemistry
3	Dave	English

You can use slicing on the column names too!

my_df.loc[:3, 'Name':"Major"]

	Name	Age	Major
0	Alice	20	Statistics
1	Bob	21	History
2	Charlie	22	Chemistry
3	Dave	23	English

`.loc[]` Using a Boolean

As with [] we can use a boolean to return only certain rows (and/or columns)
Must supply a boolean of the correct length!

my_df['Age'] > 21 #create a boolean array

	Age
0	False
1	False
2	True
3	True
4	True
5	False
6	True

dtype: bool

my_df.loc[my_df['Age'] > 21]

	Name	Age	Major
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math
6	Greg	22	Statistics

Here we gain the advantage of being able to select columns of interest at the same time as subsetting the rows!

my_df.loc[my_df['Age'] > 21, ["Name", "Age"]] #still can return only selected columns too

	Name	Age
2	Charlie	22
3	Dave	23
4	Eve	22
6	Greg	22

You can use booleans for both rows and columns
Also, .isin() is a very convenient operator!

my_df.columns.isin(["Name", "Age"]) #returns a boolean of the same length as our number of columns!

array([ True,  True, False])

my_df.loc[my_df["Age"] > 21, my_df.columns.isin(["Name", "Age"])]

	Name	Age
2	Charlie	22
3	Dave	23
4	Eve	22
6	Greg	22

Operations on Data Frames

.head() and .tail() methods give the first few and last rows, respectively

my_df.head()

	Name	Age	Major
0	Alice	20	Statistics
1	Bob	21	History
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math

my_df.tail()

	Name	Age	Major
2	Charlie	22	Chemistry
3	Dave	23	English
4	Eve	22	Math
5	Francesca	21	Civil Engineering
6	Greg	22	Statistics

.shape attribute contains the dimensions of the data frame

my_df.shape

(7, 3)

.info() method gives information about the data frame

my_df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 7 entries, 0 to 6
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   Name    7 non-null      object
 1   Age     7 non-null      int64 
 2   Major   7 non-null      object
dtypes: int64(1), object(2)
memory usage: 296.0+ bytes

my_df2.info()

<class 'pandas.core.frame.DataFrame'>
Index: 5 entries, a to e
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   1st     5 non-null      float64
 1   2nd     5 non-null      float64
 2   3rd     5 non-null      float64
dtypes: float64(3)
memory usage: 332.0+ bytes

Obtain a quick contingency table with the .value_counts() method on a column (so a .Series method really)

my_df["Major"].value_counts()

	count
Major
Statistics	2
History	1
Chemistry	1
English	1
Math	1
Civil Engineering	1

dtype: int64

Quick Video

This video shows the creation of a DataFrame and how to add a new column and reorder the rows (or columns) with .sort_value().

We also check out a few other methods such as

.dropna(): removes rows with empty cells (returns a new dataset; add inplace = True to replace)
.fillna(): replaces missing values with something
my_df.describe() for basic stats

Remember to pop the video out into the full player.

The notebook written in the video is available here.

from IPython.display import IFrame
IFrame(src="https://ncsu.hosted.panopto.com/Panopto/Pages/Embed.aspx?id=2dcc67df-5465-4570-83b7-b0ff0008e9a7&autoplay=false&offerviewer=true&showtitle=true&showbrand=true&captions=false&interactivity=all", height="405", width="720")

Recap

Data Frames are great for storing a data set (2D)
- Rows = observations, Columns = variables
- Many ways to create them (from a dictionary, list, array, etc.)
- Many ways to subset them!
- .info(), .head() and other useful methods!

If you are on the course website, use the table of contents on the left or the arrows at the bottom of this page to navigate to the next learning material!

If you are on Google Colab, head back to our course website for our next lesson!

Pandas Data Frames

Creating a DataFrame

Creating a Data Frame from Lists

Creating a Data Frame from a Dictionary

Creating a Data Frame from a NumPy Array

Indexing a Data Frame

Indexing Columns with []

Indexing Rows by Slicing with []

Indexing Rows Using a Boolean Array with []

Compound Logicals

Indexing a Data Frame’s Rows & Columns

Indexing Rows with .iloc[]

.iloc[] for Returning Rows and Columns

Indexing Rows with .loc[]

.loc[] for Returning Rows and Columns

.loc[] Using a Boolean

Operations on Data Frames

Quick Video

Recap

Creating a `DataFrame`

Creating a Data Frame from a `NumPy` Array

Indexing Columns with `[]`

Indexing Rows by Slicing with `[]`

Indexing Rows Using a Boolean Array with `[]`

Indexing Rows with `.iloc[]`

`.iloc[]` for Returning Rows and Columns

Indexing Rows with `.loc[]`

`.loc[]` for Returning Rows and Columns

`.loc[]` Using a Boolean