Data Analysis with Pandas and Python

In this lesson, we create a new Jupyter Notebook for the Series section of the course. The pandas Series object is a one-dimensional labelled array that combines the best features of a Python list and a Python dictionary.

A pandas Series can be created with the pd.Series() constructor method. In this lesson, we'll practice creating a few sample Series by feeding in Python lists as inputs to the constructor method.

The pd.Series() constructor method accepts a variety of inputs. In this lesson, we'll create a Series from a Python dictionary. We'll also explore the differences between the pandas Series and Python's built-in objects, and understand how the index operates in a Series.

Objects in pandas have attributes and methods. Methods actively interact with and modify the object while attributes return information about the object's state. In this lesson, we'll use the .values, .index, and .dtype attributes on a Series object.

In this lesson, we'll continue our exploration of methods on pandas object. We'll utilize the .sum(), .product(), and the .mean() mathematical methods on a sample Series.

Parameters are the options that a method has. Arguments are the choices we choose for those options. In this lesson, we'll learn the syntax of supplying arguments to parameters on pandas methods.

The time has come to import our first datasets into our Jupyter Notebook work environment. In this lesson, we use the pd.read_csv method to import a dataset of Pokemon and Google stock prices. We also explore the squeeze parameter, which coerces an imported one-column DataFrame into a Series object.

Use the .head() and .tail() methods to return a specified number of rows from the beginning or end of a Series. The methods return a brand new Series.

See how the Series interacts with Python's built-in functions including len, type, sorted, list, dict, max, and min. pandas works seamlessly with all of them.

Get some new Series attributes on the pandas Series object including .size, .name, and .is_unique. Attributes return information about the object; methods directly modify the object.

Modify the argument to the inplace parameter on a Series method to permanently modify the object it is called on. This is an alternative to reassigning the new object to the same variable.

Call the .sort_index() method on a pandas Series to sort it by the index instead of its values.

Use Python's in keyword and attributes to check if a value exists in either the values or index of a Series. If the .index or .values attribute is not included, pandas will default to searching among the Series index.

In this lesson, we walk through how to use square bracket notation to extract one or more Series values by their index position. The index position represents the order of the row within the Series.

In this lesson, we explore how to use use bracket notation to extract one or more values from a Series by their index labels.

In this lesson, we explore an alternative approach to extracting one or more values from a Series by index position or index label. The get method accepts the key to search for in the index as well as a fallback to value in return if the key is not found.

In this lesson, we invoke common mathematical methods including .count(), .sum(), and .mean() on a Series object.

Call the .idxmax() and .idxmin() methods to extract the index positions of the highest or lowest values in a Series. We'll see how these can be used to extract the highest / lowest values as well.

Call the .value_counts() method to count the number of the times each unique value occurs in a Series. The result will be a brand new Series where each unique value from the original Series serves as an index label.

Call the .apply() method and feed it a Python function as an argument to use the function on every Series value. This is helpful for executing custom operations that are not included in pandas or numpy.

Call the .map() method to tie together the values from one object to another. We'll practice with (a) two Series and (b) a Series and a dictionary object.

Review the pandas Series concepts you explored in this module with this action-packed quiz!

In this lesson, we create a new Jupyter Notebook for this section, our first to cover the 2-dimensional DataFrame object. We walk through what dimensions are and also introduce the nba.csv dataset we'll be exploring throughout the section.

The pandas Series and DataFrame objects share many attributes and methods. this lesson, we'll review attributes like .index, .values, .shape, .ndim, and .dtypes and see what they return on a 2D DataFrame. We'll also introduce new attributes including .columns and .axes that are exclusive to DataFrames.

Series and DataFrame may share attributes and methods but they are still different objects. In this lesson, we'll see how identical methods operate differently depending on the pandas object they are called on.

In this lesson, we'll select two or more columns from a pandas DataFrame. We'll still need bracket syntax to extract but now we'll include a Python list to specify the specific columns we'd like to pull out. The result will be a new DataFrame.

In addition to extracting existing columns, bracket syntax can be assed to create a new column on the right end of a DataFrame and populating it values. In this lesson, we'll also dive into the alternate .insert() method to insert a column into the middle of a DataFrame.

A broadcasting operation performs an operation on all values within a pandas object. In this lesson, we'll apply several mathematical operations to values in a DataFrame column (i.e. a Series) including the .add(), .sub(), .mul() and .div() methods. We'll also cover the operator shortcuts for these methods.

Refresh your memory on the .value_counts() Series method, which counts the number of times each unique value occurs within the Series. The result is a brand new Series.

Null values are represented with a NaN marker in pandas. In this lesson, we'll delete rows with null (NaN) values by caling the .dropna() method. We'll also modify the arguments of the method to specify how to select the rows to be deleted.

One alternative to dropping null value is populating them with a predefined value. In this lesson, we'll call the .fillna() method to accomplish this. We'll practice the method on both DataFrame and Series objects.

Data types in a Series will not always be the types we want or the types that are best for efficiency. In this lesson, we'll convert the data types in a Series with the .astype() method. We'll also show how to overwrite an old Series with a Series of new data values.

In this lesson, we'll explore additional parameters to the .sort_values() method to sort the values in a DataFrame based on the values in multiple columns. We'll also cover how to specify different sort orders (ascending vs. descending) on different columns.

Call the .sort_index() method to sort the values in a DataFrame based on their index positions or labels instead of their values.

Values in a Series can be ranked in order with the .rank() method. In this lesson, we'll practice this method on a numeric Series and then confirm the results through our own sort test.

In this lesson, we create the Jupyter Notebook for our new section, our second focusing on the 2D DataFrame object. The focus of this module is filtering data or, in other words, how we extract rows based on one or more conditions. We also introduce the employees.csv dataset that we'll be working with.

In this lesson, we'll explore more complex row filtering based on multiple conditions. The syntax requires some additional symbols (&) to specify that we want to check the truthiness of multiple conditions.

In this lesson, we'll continue filtering rows from the DataFrame based on multiple conditions. However, this time we'll use a new symbol ( | ) to specify an OR check. This requires only one of the tested conditions to evaluate to True in order to include the row.

One common problem is data analysis is extracting rows whose values fall within a collection of values. Instead of writing multiple OR statements, we can use the isin method and pass in a list of values to match against.

Call the .isnull() and .notnull() methods to create Boolean Series for extracting rows will null or non-null values. Both methods return a Boolean Series object, which can be passed within square brackets after the DataFrame to filter it.

Call the .between() method to extract rows where a column value falls in between a predefined range. This is another method that return a Boolean Series object, which can be passed within square brackets after the DataFrame to filter it.

Call the .duplicated() method to create a Boolean Series and use it to extract rows that have duplicate values. This is another example of a method that returns a Boolean Series object, which can be passed within square brackets after the DataFrame to filter it.

An alternative option to identifying duplicate rows and removing them through filtering is the .drop_duplicates() method. In this lesson, we'll invoke the method to remove rows with duplicate values in a DataFrame. We'll also provide custom arguments to modify how the method operates.

Call the .unique() and .nunique() methods on a Series to extract the unique values and a count of the unique values. These methods are one letter apart but return completely different results. In addition, the .nunique() requires an additional argument to include null values in its count.

In this lesson, we introduce the third DataFrame-focused section of the course. The upcoming lessons cover how to:

• set and reset an index in a DataFrame

• retrieve DataFrame rows by index position or index label

• set new values for one or more cells in the DataFrame

• rename or delete rows or columns

• extract a random sample of rows / columns

and more!

Pandas will default to assigning a data structure a numeric index starting at 0. In this lesson, we'll explore how we can use the set_index and reset_index methods to customize and reset the index labels of a DataFrame object.

In this lesson, we'll use the .loc[] accessor to retrieve DataFrame rows based on index label. We also look at providing multiple index labels within a list.

In this lesson, we'll use the .iloc[] accessor to retrieve DataFrame rows based on index position. We also look at providing multiple index positions within a list.

The .loc[] and loc accessors can take second arguments to specify the column(s) that should be extracted. In this lesson, we'll practice extracting movies from our dataset with this syntax.

In this lesson, we'll discuss how to assign a new value to one cell in a DataFrame. We first extract the cell value by using the .ix[] method with a row and column argument, then reset its value with the assignment operator (=).

In this lesson, we explore how we can overwrite multiple values in a DataFrame by passing a Boolean Series to the loc accessor. We also discuss how we can accidentally overwrite values on a slice of data rather than the original DataFrame itself.

In this lesson, we practice 3 different syntactical options to delete rows or columns from a DataFrame. They include the .drop() method, the .pop() method, and Python's built in del keyword.

In this lesson, we'll call the .sample() method to pull out a random sample of rows or columns from a DataFrame. We'll specify the number of values to include by modifying the n parameter.

There is a shortcut available to pull out the rows with the smallest or largest values in a column. Instead of sorting the rows and using the .head() method, we can call the .nsmallest() and .nlargest() methods. We'll dive into these methods and their parameters in this lesson.

Sometimes, you'll want to retain the structure of the original DataFrame when you extract a subset. In this lesson, we'll call the .where() method to return a modified DataFrame that holds NaN values for all rows that don't match our provided condition.

Our filtration process so far has involved using official pandas syntax. In this lesson, I'll introduce the .query() method, an alternate string-based syntax for extracting a subset from a DataFrame.

In this review of a lesson from our Series Module, we'll call the .apply() method on a Series to apply a Python function on every value within it. This will act as a foundation for the next lesson, where we'll invoke the same method on a DataFrame.

The .apply() method applies a Python function on a row-by-row basis in a DataFrame. In this example, we'll create a custom ranking function for our films, then demonstrate how it can be applied to a DataFrame.

The default bracket syntax extracts a component of the larger DataFrame. Any operations on that component will affect the larger DataFrame. If we want to separate the two objects, we can use the .copy() method, which create an independent copy of a pandas object.

Datasets can arrive with plenty of improperly formatted text data. The Working with Text Data section introduces the methods available in pandas to clean your data. In this introductory lesson, we create a Jupyter Notebook for this sectionand import a CSV file with public data on employees in the city of Chicago. We also optimize the DataFrame for speed and efficiency.

The str.replace() method replaces a substring within a string with another value for all Series values. In this lesson, we use it to convert our Employee Annual Salary column to store numeric values instead of text ones.

In this lesson, we'll introduce the .str.contains(), .str.startswith(), and .str.endswith() methods. All three create a Boolean Series, which can be used to extracting rows from a DataFrame. We'll also discuss case normalization to increase the accuracy of our results.

In this lesson, we'll invoke the .str.strip() family of methods to remove leading and trailing whitespace from strings in a Series. The .str.lstrip() method removes whitespace from the left side (beginning) of a string, the .str.strip() method removes whitespace from the right side (end) of a string, and the .str.strip() method does both.

The past few lessons focused on calling string methods on the values in a column of our dataset. In this lesson, we'll familiarize ourselves with calling the same string methods on the index labels and column names of a DataFrame.

Strings can often contain multiple pieces of information that are separated by a common delimiter. In this lesson, we'll introduce the .str.split() method, which can split a string value based on an occurrence of a user-specified value. This is equivalent to the Text to Columns feature in Microsoft Excel.

In this lesson, we'll utilize additional parameters on the .str.split() method to modify its performance. We'll extract the first names of all the employees in our dataset, a slightly more challenging puzzle than the one in the previous lesson.

In this lesson, we'll explore even more parameters on the .str.split() method. The expand parameter allows us to expand the generated Python list into DataFrame columns while the n parameter limits the total number of splits.

A DataFrame or Series can hold multiple levels or layers in its index. The object that stores this index is called a MultiIndex. In this lesson, we create a Jupyter Notebook for this section and explore a new bigmac.csv dataset.

In this lesson, we'll create a multi-layer MultiIndex on a DataFrame with the .set_index() method. The method can be passed a list instead of a string to transfer multiple columns to the index.

The index attribute returns the underlying object that makes up the index of a DataFrame. In this lesson, we invoke the get_level_values method on the index to extract the values from one of its levels. We show how this can done either by the layer's index position or by its name.

The levels or layers of a MultiIndex can be changed. In this lesson, we'll call the .set_names() method on a MultiIndex object to rename its levels.

In this lesson, we explore how the sort_index method operates on a MultiIndex DataFrame. We show how to sort all levels in the same order as well as how to vary up the sort order for different levels.

In this lesson, we review the familiar .loc[] and .iloc[] accessors for extracting rows from a MultiIndex DataFrame. We discuss how to package up multiple level values within a tuple to be more precise in communicating what we want to extract.

In this lesson, we invoke the transpose method on a MultiIndex DataFrame to swap its row and column axes.  We then discuss how to use the loc accessor to attribute a column from a MultiIndex column index.

The swaplevel method swaps two levels within a MultiIndex. In this lesson, we practice moving around levels in the bigmac dataset. If the MultiIndex consists of only two levels, no additional arguments are required.

The .unstack() method does the exact opposite of the .stack() method. It moves an index level from the rows to the columns. In this lesson, we'll call the method without any arguments.

In this lesson, we'll continue our exploration of the .unstack() method. We'll introduce the numerous argument types we can feed it as arguments including positive integers, negative integers, and index level names.

Multiple levels of the row-based MultiIndex can be shifted with the .unstack() method. In this lesson, we'll explore how to provide a list argument to the level parameter to move multiple layers at a time. We'll also introduce the fill_value parameter to plug in missing values in the resulting DataFrame.

In this lesson, we'll reorganize the unique values in a DataFrame column as the column headers with the .pivot() method. This can be a particularly effective method for shortening the length of the DataFrame.

In this lesson, we'll emulate Excel's Pivot Table functionality with the .pivot_table() method. We'll explore the values, index, column, and aggfunc parameters. We'll also discuss the variety of aggregation functions that we can use including sum, count, max, and min.

The pandas DataFrameGroupBy object allows us to create groupings of data based on common values in one or more DataFrame columns. In this lesson, we'll setup a new Jupyter Notebook in preparation for this module.

The GroupBy object does not offer us much of substance until we call a method on it. In this lesson, we'll call the .first(), .last(), and .size() methods on a GroupBy object to gain a better understanding of its internal data structure.

The .get_group() method extracts a grouping from a GroupBy object. In this lesson, we'll practice pulling out a few groups from our companies dataset.

Aggregation methods allow us to perform calculations on all groupings within a GroupBy object. In this lesson, we'll call some mathematical methods on the groups, including the .sum(), .mean(), and .max() methods.

A GroupBy object does not have to be made up of values from a single column. In this lesson, we'll create a new GroupBy object based on unique value combinations from two of our DataFame columns.

A standard Python for loop can be used to iterate over the groups in a pandas GroupBy object. In this lesson, we'll loop over all of our gropings to extract selected rows from each inner DataFrame. We'll append these rows to a running DataFrame and then view the final result.

Welcome to the Merging, Joining, and Concatenating section! In this module, we'll cover how to combine data from multiple DataFrames into one. In this section, we create a new Jupyter Notebook and introduce the 4 CSV files that we will be using.

The pd.concat method concatenates two or more DataFrames together. The process is simple when the DataFrames have an identical structure (i.e. the same column names). In this lesson, we also explore how to replace the merged index with a newly generated once.

In this lesson, we use the keys parameter on the pd.concat method to label each concatenated DataFrame with a unique identifier. This parameter yields a MultiIndex DataFrame where the outermost layer holds the keys and the innermost layer holds each DataFrame's original index values.

An inner join merges the values in two DataFrames based on common values across one or more columns. In this lesson, we'll explore the concept by merging on identical values in a single column.

This lesson continues our exploration of the .merge() method. This time, we'll merge the values in two DataFrames based on common values in multiple columns. We'll also validate the data with some filtering.

An outer join combines values that exist in either DataFrame into a central DataFrame. In this lesson, we'll invoke the .merge() method with a modified argument to the how parameter to perform an outer join on our weekly sales data sets.

DataFrames may come equipped with different names for columns that represent the same data. In this lesson, we'll talk about how to utilize the left_on and right_on parameters to specify how to match values in differently named columns across two DataFrames.

Our merges so far have involved matches based on common column values. In this lesson, we'll explore how to merge DataFrames based on common index labels.

Call the .join() method, a simple method to concatenate two DataFrames vertically when they share the same index. This is a shortcut to a more explicit .merge() method.

Call the pd.merge() method on the pandas library to merge two DataFrames. This is an alternate syntax to calling the .merge() method directly on a DataFrame.

The Working with Dates and Times section offers a review of Python's built-in datetime objects as well as a comprehensive introduction to similar tools in the pandas library. In this lesson, we setup our Jupyter Notebook and import Python's datetime module.

Python includes built-in date and datetime objects for working with dates and times. This lesson offers a review of how we can create these objects as well as some of the attributes (.year, .month, .day etc) that are available on them.

The pandas library includes its own Timestamp object to represent moments in time. In this lesson, we'll use the pd.Timestamp() constructor method with a variety of inputs (strings, date objects, date objects) to create some Timestamp objects.

A DatetimeIndex is a pandas object for storing multiple Timestamp objects. In this lesson, we'll create a few DatetimeIndex objects from Python lists.

The pd.to_datetime() method is a convenience method to convert various inputs to pandas-focused objects. In this lesson, we'll pass a variety of inputs (date objects, datetime objects, strings, lists) to the constructor method to see what it returns.

In this lesson, we'll see how the pd.date_range() method operates with arguments for the start and periods parameters. This approach creates a set number of dates beginning from a specific point.

In this lesson, we'll see how the pd.date_range() method operates with arguments for the end and periods parameters. This approach creates a set number of dates, proceeding backwards from a specified date point. We'll also continue our exploration of the freq parameter to vary the durations between each Timestamp.

The .dt accessor on a Series of Timestamp object allows us to access specific datetime properties, much like the .str accessor allows us to call specific methods on a Series of strings. In this lesson, we'll explore popular attributes like .day, .weekday_name, and .month.

Upcoming lessons rely on the pandas-datareader library to fetch financial datasets from Yahoo Finance. In this lesson, we'll  install the pandas-datareader library.

On a Mac system, open the Terminal. On a Windows machine, look for the Anaconda Prompt from the Start Menu.

Once the application is open, run the following commands.

1. conda activate followed by your environment name (for example, conda activate pandas_playground)

2. conda install pandas-datareader

In this lesson, we use our pandas_datareader library to fetch stock data for Microsoft. The result arrives in a DataFrame object with a DatetimeIndex.

Extracting rows from a DataFrame with a DatetimeIndex is no different than in previous sections. In this lesson, we review the familiar .loc and .iloc accessors. As a reminder, these methods use a pair of square brackets to target one or more rows by either index label or index position.

In this lesson, we'll explore some of the attributes and methods on a pandas Timestamp object. We'll also practice extracting similar information from a complete DatetimeIndex of Timestamps.

In this lesson, we'll use the pd.DateOffset object to add hours, days, weeks, months, and years to each value in a DatetimeIndex.

In this lesson, we'll explore how we can use timeseries offsets to arrive at specific datetime values (such as the end of the month or the start of the year).

Over the next two lessons, we'll explore the pandas Timedelta object which represents durations. A Timedelta represents a distance of time while a Timestamp represents a specific moment in time.

In this lesson, we'll create a Series of Timedelta objects by calculating the duration differences between two columns of Timestamps. Time difference operations can be easily performed with the subtraction ( - ) sign.