Python_Data_Analysis_Visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python for Data Analysis and Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This workshop is developed by Ramandeep Makhija with the assistance of ChatGPT (2023)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a high-level programming language known for its simplicity and readability. It provides a straightforward and beginner-friendly syntax that makes it easier to learn and write code. Python is widely used in various domains, including web development, data analysis, artificial intelligence, and automation. It offers a rich set of libraries and frameworks that simplify complex tasks and enable developers to build powerful applications efficiently. In summary, Python is a versatile and accessible programming language that is widely adopted for its simplicity, versatility, and extensive ecosystem of libraries and tools>\n",
    "\n",
    "The best way to learn a programming language is to do something useful, therefore this hands-on introductory workshop will cover:\n",
    "\n",
    "#### Working with Data in Python\n",
    "* Introduction to data structures(list, dictionaries, tuples)\n",
    "* Accessing and manipulating data in data structures\n",
    "\n",
    "#### Data Analysis and Visualization\n",
    "* Introduction to Pandas for data analysis\n",
    "* Loading and exploring data with Pandas\n",
    "* Data Cleaning and preprocessing\n",
    "* Data Visualization with matplotlib and Seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Structures\n",
    "\n",
    "Data structures are containers used to organize and store data in a computer program. They provide a way to efficiently access, manipulate, and represent data. \n",
    "\n",
    "Now we will go through some commonly used data structure in Python with some examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists:\n",
    "\n",
    "Lists are ordered collections that can store elements of different data types. They are denoted by square brackets and can be modified (mutable)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Empty list\n",
    "a = []\n",
    "\n",
    "# List with three different data types\n",
    "b = [1, 2, 3, 'hello', True]\n",
    "\n",
    "# You can also create a list using a list() constructor \n",
    "c = list((1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use print statements to look at the values of the lists you created \n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can access elements with a list using the indices\n",
    "# In Python indices start from 0 instead os 1\n",
    "\n",
    "# To access first element of list b\n",
    "print(b[0])\n",
    "\n",
    "# Third element of list c is\n",
    "print('The third element of list c is: ', c[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also slice and access multiple elements from the list\n",
    "\n",
    "# Create a new list d from 3rd to last element from list b\n",
    "d = b[2:]\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## We can also add or remove elements from a list\n",
    "\n",
    "# Lets print value of list a\n",
    "print('List a before adding an element: ', a)\n",
    "\n",
    "# Lets add an integer 10 to empty list a\n",
    "a.append(10)\n",
    "print('List a after appending: ', a)\n",
    "\n",
    "# Removthe added integer 10 from list a\n",
    "a.remove(10)\n",
    "print('List a after removing: ', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "* Create a list called fruits with the following fruits: \"apple\", \"banana\", \"orange\", \"grape\", \"kiwi\". Print the third item in the list.\n",
    "* Add \"mango\" to the fruits list. Print the updated list.\n",
    "* Remove \"orange\" from the fruits list. Print the updated list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Write your exercise code below\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries:\n",
    "\n",
    "Dictionaries store data as key-value pairs. Each value is associated with a unique key, allowing fast access to data. They are denoted by curly braces and can be modified (mutable)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Empty dictionary using curly brackets\n",
    "e = {}\n",
    "\n",
    "# Empty dictionary using dict() constructor\n",
    "f = dict()\n",
    "\n",
    "# A two element dictionary with name as key and age as value using curly brackets\n",
    "g = {'Sam' : 28, 'Abby' : 21}\n",
    "\n",
    "# Two element dictionary with name as key and age as value using dict() constructor\n",
    "h = dict([['Sam', 28], ['Abby', 21]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets print the values of dictionaries above\n",
    "print('Dictionary e: ', e)\n",
    "print('Dictionary f: ', f)\n",
    "print('Dictionary g: ', g)\n",
    "print('Dictionary h: ', h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## We can also create a dictionary of dictionaries\n",
    "\n",
    "# Lets create a dictionary with age and department of two people\n",
    "i = {'Sam': {'Age': 28, 'Department': 'Physics'}, 'Abby': {'Age': 21, 'Department': 'Computer Science'}}\n",
    "print('Dictionary i: ', i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now lets access the elements from a dictionay i \n",
    "print(\"Abby's information from dictionary i: \", i['Abby'])\n",
    "\n",
    "# To Just acces Sam's department from dict i\n",
    "print(\"Sam's department from dict i: \", i['Sam']['Department'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Dictionaries are mutable\n",
    "\n",
    "# Add another person to dictionary i\n",
    "i['Peter'] = {'Age': 22, 'Department': 'Physics'}\n",
    "\n",
    "# Print the dictionary i afetr adding a new person\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "* Create a dictionary called student with the following key-value pairs: \"name\" - \"John\", \"age\" - 20, \"city\" - \"New York\". Print the value associated with the \"age\" key.\n",
    "* Add a new key-value pair to the student dictionary: \"grade\" - \"A\". Print the updated dictionary.\n",
    "* Change the value of the \"age\" key to 21. Print the updated dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Write your exercise code below\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples:\n",
    "\n",
    "Tuples are similar to lists but are immutable (cannot be modified once created). They are denoted by parentheses and are typically used to store related data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a tuple using round brackets\n",
    "j = (1, 2, 3, 4)\n",
    "\n",
    "# Create a tuple using tuple() constructor\n",
    "k = tuple([1, 2, 3, 4, 5])\n",
    "\n",
    "# We can also create a tuple from a list using a tuple constructor\n",
    "l = tuple(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets print the values of tuples created\n",
    "print('tuple j: ', j)\n",
    "print('tuple k: ', k)\n",
    "print('tuple l: ', l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We cannot change or update a value of a tuple, let's try\n",
    "j[0] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# however we can access the values of a tuple like we did for lists using indices\n",
    "print('Fourth element from tuple l: ', l[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "* Create a tuple called colors with the following colors: \"red\", \"green\", \"blue\". Print the second item in the tuple.\n",
    "* Attempt to modify an item in the colors tuple (e.g., colors[0] = \"yellow\"). Observe and explain the error.\n",
    "* Unpack the colors tuple into three variables: color1, color2, and color3. Print the values of the variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Write your exercise code below\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn more about data structures, you can refer to [this](https://docs.python.org/3/tutorial/datastructures.html 'Data Structure') documentation. It provides detailed explanations and insights into different types of data structures and how they can be used in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas\n",
    "\n",
    "Pandas is a popular Python library for data manipulation and analysis. It offers powerful data structures and tools, making it widely used in various domains. It simplifies data tasks, integrates well with other libraries, and has a large and active community. \n",
    "\n",
    "Key features of Pandas:\n",
    "* Data Structure - Pandas provides two primary data structures: Series and DataFrame.\n",
    "* Data Manipulation - Pandas offers a wide range of functions and methods for data manipulation, such as filtering, sorting, merging, reshaping, and aggregating data.\n",
    "* Data Analysis - Pandas offers a wide range of functions and methods for data manipulation, such as filtering, sorting, merging, reshaping, and aggregating data.\n",
    "* Integration with other libraries - Pandas seamlessly integrates with other Python libraries, such as NumPy, Matplotlib, and scikit-learn. \n",
    "* Efficiency - Pandas is optimized for performance and efficiency. It handles large datasets effectively and provides fast data processing capabilities, making it suitable for working with real-world data.\n",
    "\n",
    "To learn more about Pandas, you can refer to the official Pandas [documentation](https://pandas.pydata.org/docs/user_guide/index.html#user-guide), which provides detailed explanations, examples, and tutorials.\n",
    "\n",
    "Additionally, there are several online tutorials, courses, and books available that offer comprehensive guidance and practical examples for learning Pandas effectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Getting started with Pandas\n",
    "\n",
    "To use Pandas, you need to install it first. You can install Pandas using the Python package manager pip by running the command: pip install pandas.\n",
    "\n",
    "Once installed, you can import the Pandas library in your Python script or Jupyter Notebook using the following convention:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importing other necessary libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import other necessary libraries like Numpy, Matplotlib and Seaborn. Here's brief explanation for all three libraries and liks to their official documentations.\n",
    "\n",
    "* NumPy:\n",
    "    NumPy is a Python library for numerical computing. It provides powerful tools for working with arrays and performing mathematical operations efficiently. NumPy's official documentation offers detailed explanations, examples, and tutorials on how to use the library effectively.\n",
    "    Official documentation: [NumPy Documentation](https://numpy.org/doc/)\n",
    "\n",
    "* Matplotlib:\n",
    "    Matplotlib is a plotting library for creating static, animated, and interactive visualizations in Python. It offers a wide range of plotting options and customization capabilities. The official Matplotlib documentation provides comprehensive guidance on using the library and showcases various plot types and customization techniques.\n",
    "    Official documentation: [Matplotlib Documentation](https://matplotlib.org/stable/users/index.html)\n",
    "\n",
    "* Seaborn:\n",
    "    Seaborn is a Python data visualization library built on top of Matplotlib. It provides a high-level interface for creating attractive statistical graphics. The official Seaborn documentation offers detailed explanations of the library's features, tutorials on using different plot types, and guidance on customization options.\n",
    "    Official documentation: [Seaborn Documentation](https://seaborn.pydata.org/)\n",
    "\n",
    "These official documentation links provide in-depth resources to learn more about the libraries, their functionalities, and how to use them effectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dowloading and loading the dataset as dataframe\n",
    "\n",
    "Let's start with using the Netflix dataset for exploratory data analysis (EDA) and visualizations. Here's a step-by-step guide to get you started:\n",
    "\n",
    "Download the Netflix dataset:\n",
    "\n",
    "Visit the Netflix Movies and TV Shows dataset page on Kaggle: https://www.kaggle.com/shivamb/netflix-shows\n",
    "Click on the \"Download\" button to download the dataset file (e.g., netflix_titles.csv)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Loading the dowloaded dataset as a dataframe\n",
    "df = pd.read_csv('netflix_titles.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exploratory data analysis (EDA)\n",
    "\n",
    "About this Dataset: Netflix is one of the most popular media and video streaming platforms. They have over 8000 movies or tv shows available on their platform, as of mid-2021, they have over 200M Subscribers globally. This tabular dataset consists of listings of all the movies and tv shows available on Netflix, along with details such as - cast, directors, ratings, release year, duration, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets explore the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## First 5 rows of the data\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## If you want to look at first 10 rows or more\n",
    "df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Now lets check the dimension of the dataset - number of rows and columns\n",
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Now lets look at the column header/names\n",
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Overview of the columns\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An \"object column\" in Pandas refers to a column in a DataFrame that contains data of the Python object data type. It is a catch-all data type that can store various types of data, including strings, mixed data types, or custom objects. Object columns are flexible but may require conversion to more appropriate data types for efficient data manipulation and analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Lets look at missing values in the data set\n",
    "df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.heatmap(df.isnull())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set a clearer color palette\n",
    "cmap = sns.cm.rocket_r\n",
    "\n",
    "# Increase the size of the heatmap\n",
    "plt.figure(figsize=(10, 6))\n",
    "\n",
    "# Add labels to the x and y axes\n",
    "plt.xlabel(\"Columns\")\n",
    "plt.ylabel(\"Rows\")\n",
    "\n",
    "# Add a title to the heatmap\n",
    "plt.title(\"Missing Values Heatmap\")\n",
    "\n",
    "# Customize the heatmap grid\n",
    "sns.heatmap(df.isnull(), cmap=cmap, cbar=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Handling missing values\n",
    "\n",
    "Drop rows with missing values\n",
    "\n",
    "`df_cleaned = df.dropna()`\n",
    "\n",
    "Fill missing value with specefic values\n",
    "\n",
    "`df_filled = df.fillna('N/A')`\n",
    "\n",
    "Replace missing values with mean, median or mode\n",
    "\n",
    "`df['column_name'].fillna(df['column_name'].mean(), inplace=True)`\n",
    "\n",
    "Remember to consider the nature of the data and the impact of handling missing values in a specific way. It's important to use domain knowledge and make informed decisions based on the context of your analysis.\n",
    "\n",
    "You can apply these techniques to specific columns or the entire dataset, depending on the specific requirements of your analysis. Additionally, Pandas provides various methods and parameters to handle missing values, such as fillna(), dropna(), and interpolate().\n",
    "\n",
    "Before applying any data cleaning operations, it's essential to understand the nature of missing values, their potential causes, and the implications of different approaches to handling them.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Now lets check if we have any duplicates\n",
    "df.duplicated().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Checking for unique values for 'type' column\n",
    "df['type'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Checking value counts for 'type' column\n",
    "df['type'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## We can also plot a countplot or a pie chart to do the same\n",
    "\n",
    "# Countplot\n",
    "sns.countplot(x='type', data=df)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set a visually appealing color palette\n",
    "sns.set_palette(\"pastel\")\n",
    "\n",
    "# Set a white background\n",
    "sns.set_style(\"whitegrid\")\n",
    "\n",
    "# Create the countplot\n",
    "ax = sns.countplot(x='type', data=df)\n",
    "\n",
    "# Add labels and title\n",
    "plt.xlabel(\"Type\")\n",
    "plt.ylabel(\"Count\")\n",
    "plt.title(\"Distribution of Types\")\n",
    "\n",
    "# Customize the plot aesthetics\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the count of each unique value in the 'type' column\n",
    "type_counts = df['type'].value_counts()\n",
    "\n",
    "# Create a white background for the plot\n",
    "plt.figure(facecolor='white')\n",
    "\n",
    "# Create a pie chart\n",
    "plt.pie(type_counts, labels=type_counts.index, autopct='%1.1f%%', startangle=90)\n",
    "\n",
    "# Add a title to the chart\n",
    "plt.title('Distribution of Types')\n",
    "\n",
    "# Set the aspect ratio to be equal to display a circular pie chart\n",
    "plt.axis('equal')\n",
    "\n",
    "# Display the chart\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Now lets look at another column release year\n",
    "df['release_year'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Lets create a histogram to visualize distributuion of 'release_year' column\n",
    "sns.histplot(df['release_year'], bins=30, kde=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set a visually appealing color palette\n",
    "sns.set_palette(\"deep\")\n",
    "\n",
    "# Set a white background with grid lines\n",
    "sns.set_style(\"darkgrid\")\n",
    "\n",
    "# Create the histogram plot\n",
    "sns.histplot(df['release_year'], bins=30, kde=True)\n",
    "\n",
    "# Add labels and title\n",
    "plt.xlabel('Release Year')\n",
    "plt.ylabel('Count')\n",
    "plt.title('Distribution of Release Years')\n",
    "\n",
    "# Customize the plot aesthetics\n",
    "plt.xticks(rotation=45)\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Lets look at the earliest and the lates release years\n",
    "earliest_year = df['release_year'].min()\n",
    "latest_year = df['release_year'].max()\n",
    "print('Earliest Release Year:', earliest_year)\n",
    "print('Latest Release Year:', latest_year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Exercise\n",
    "Using the above dataset, create a bar plot to visualize the distribution of content by country for the top 10 countries with the most content.\n",
    "\n",
    "Instructions:\n",
    "\n",
    "* Calculate the count of content by country and select the top 10 countries\n",
    "* Create a barplot using sns.barplot()\n",
    "* Label both the axes\n",
    "* Add a tilte\n",
    "* Interpret the bar plot and identify the top 3 countries with the highest number of content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Write your exercise code below\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}