tu006_Python_IO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ebe72e68",
   "metadata": {},
   "source": [
    "## Reading and writing data files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc55aeee",
   "metadata": {},
   "source": [
    "### Learning goals\n",
    "\n",
    "* read data files from disk\n",
    "* practice importing python libraries \n",
    "* practice exploring data \n",
    "* understand calls to functions and variables assignments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fc18069",
   "metadata": {},
   "source": [
    "In this tutorial, we will practice with reading data files from disk. \n",
    "\n",
    "Reading files from disk is more generally known as file `i/o` where `i` and `o` stand for `i`nput and `o` utput, respectively.  Why do we need to do file `i/o`?\n",
    "\n",
    "##### File input\n",
    "\n",
    "The input case is more obvious. To analyze data, you need data to analyze. Unless you know magic, you access data from  *data files*, which are files just like a PDF documents, JPG images, or whatever, but they are specialized to some degree for containing data. Whether from a colleague, a boss, a webpage, or a government data repository, data will come in a data file that you will need to read as input in order visualize and analyze the data.\n",
    "\n",
    "##### File output\n",
    "\n",
    "The output case is perhaps less obvious. You read data into your Jupyter Notebook. The data are stored into Python variables. There are many different types of variables. We will learn about the fundamental ones. The variables can be used inside the Jupyter Notebook to make pretty graphs, and to do some cool analysis. But what if you want to share the numerical values, the results, of the analysis with someone else? In that case, you can write those values to a data file, save the file and send that to your colleagues.  They can then read in the values on their end without having to wade through your notebook and cutting and pasting or whatever.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b9ae325",
   "metadata": {},
   "source": [
    "### Let's get started!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "388be684",
   "metadata": {},
   "source": [
    "#### Import libraries\n",
    "\n",
    "As experienced in Tutorial 0001, python require importing the *Libraries* needed for the work. \n",
    "\n",
    "Python *Libraries* are organized collections of Python code (files) written to perform related tasks. You will hear of \"Libraries\", \"Packages\", and \"Modules\". Technically, Libraries contain Packages which contain modules. Modules are single files that contain useful functions. Packages are directories containing files to a set of modules (or other packages), and Libraries are directories to a set of packages. That having been said, we will tend to refer to them interchagebly as \"*useful chunks of pre-written code we can use!*\"\n",
    "\n",
    "Importing migth seem a bit tricky at the beginning as beginners do not know what libraries contains or do. So, all this at the beginning can appear a bit confusing, but later on as your experience will grow during the semester the role of each library in your work will become more clear, simpler.\n",
    "\n",
    "This tutorial will cover the three fundamental libraries for data science in Python:\n",
    "\n",
    "* [pandas](https://pandas.pydata.org/) for reading, plotting and storing advanced data orbjects. Heareafter, we will using to read data saved in a file on your computer's hard drive. The operarions to read and write files from disk are generally referred to as  `i/o` (i.e., `i`nput/`o`utput file operations) \n",
    "* [matplotlib](https://matplotlib.org/) used to make simple plots \n",
    "* [seaborn](https://seaborn.pydata.org/) to plot more complex datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "414abb94",
   "metadata": {},
   "source": [
    "##### How to run code in Jupyter\n",
    "\n",
    "*Remember, how we run code in Jupyter. There are two types of cells in this Jupyter Notebooks, text and code cellls. Text cells are in Markdown, code cells are python code. \n",
    "\n",
    "Each code cell like the ones below, can be select and then hit we can hit **shift-return** (or shift-enter)*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93150c95",
   "metadata": {},
   "source": [
    "#### Import `pandas`\n",
    "\n",
    "The first libray we import is called `pandas`. We import it using the shortname `pd`. Python programmers import libraries using nicknames. This helps making the code sorter when a library is used. For example, to use a command  `read_csv()` available in `pandas` we would need to use the following line of code `pandas.read_csv()`, using the nickname `pd` the code shortens to `pd.read_csv()`. Nicknames are standardized in python, each libray is generally called with a specific nickname. Ok, let's import `pandas`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e332af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3dc157a",
   "metadata": {},
   "source": [
    "#### Import `seaborn`\n",
    "\n",
    "After importing `pandas` we will import another library called `seaborn`. `seaborn` is one of the most used libraries for data visualization. We will import it as `sns`, the commonly used shortcut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86bef4fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb39f566",
   "metadata": {},
   "source": [
    "#### Import `matplotlib`'s `pyplot`\n",
    "\n",
    "After `seaborn`, we import anohter major library, commonly used in data science applications: `pyplot`. Note that `pyplot` is part of the larger library called `matplotlib`. So, here we are importing a sub-module, a smaller library part of a larger library. The syntax goes as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0855ede6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8229e3a",
   "metadata": {},
   "source": [
    "Now you should have these three libraries available to you via their standard nicknames: `pd`, `plt`, and `sns`.\n",
    "\n",
    "If 'sns' seems like a weird nickname for 'seaborn', I'll give you hint about it: It's an homage to one of the main characters in one of the best television series ever made. The show ran from 1999 until 2006 on NBC."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2b6909e",
   "metadata": {},
   "source": [
    "### Data preparation\n",
    "\n",
    "For this tutorial, we are going to read a data file called `006DataFile.csv`. The data was given to you and you are asked to save it inside a folder called `datasets`. The folder should be contained inside the same folder containing this Jupyter Notebook. Ideally, both `datasets` folder and Jupyter Notebook should be saved inside a GitHub repo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0245e81d",
   "metadata": {},
   "source": [
    "### Let's read some data!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a361a941",
   "metadata": {},
   "source": [
    "There are many ways that data can be stored, from excel files to tables on webpages."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8ccd14c",
   "metadata": {},
   "source": [
    "We read a file with exstension `.csv` (more on this file type in a bit) using the `pandas.read_csv()` function. But, remember, we have imported pandas as `pd`, so we read the `.csv` file, with slightly less typing, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8df1330",
   "metadata": {},
   "outputs": [],
   "source": [
    "myDataFromFile = pd.read_csv(\"datasets/006DataFile.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c0ea01f",
   "metadata": {},
   "source": [
    "This command will work \"out of the box\" if your copy of the data file is in your \"*datasets*\" directory, which should be a subdirectory of the one this notebook is in. \n",
    "\n",
    "Otherwise, you would have to change the command above to specify the path to the data file – where on the file tree the data file exists (either in '*absolute*' terms from root, or in '*relative*' terms from you current directory)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38f66b66",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions:}}$\n",
    "\n",
    "In the line of code above, what is the:\n",
    "\n",
    " - name of the library used to load the file?  [Enter answer here]\n",
    " - name of the `pandas` function we use to read the data file?  [Enter answer here]\n",
    " - data file name?  [Enter answer here]\n",
    " - name of the variable used to store the file?  [Enter answer here]\n",
    " - name of the folder containing the data file?  [Enter answer here]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67ce2b39",
   "metadata": {},
   "source": [
    "### Let's look at what we just read."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "406389b1",
   "metadata": {},
   "source": [
    "Okay, now let's look at the file. We can take a quick peek by using the `display()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f189247",
   "metadata": {},
   "outputs": [],
   "source": [
    "display(myDataFromFile)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "119ee1fc",
   "metadata": {},
   "source": [
    "Here, we can see that this file (like almost all data files) consists of rows and columns. The rows represent *observations* and the columns represent *variables*. This type of data file contains \"tidy\" data (if you have used R, you may have encountered the tidyverse). Sometimes, we will encounter data files that violate this \"rows = observations, columns = variables\" rule – untidy data – we will deal with this issue later in the class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "131ca4cb",
   "metadata": {},
   "source": [
    "A very common genertic data file type is the comma separated values file, or .csv file. This is the type of data file we just loaded (006DataFile***.csv***). As the name implies, a file in this format consists values separated by commas to form rows, and \"carriage returns\" (CR) or \"line feeds\" (LF) marking the end of each row."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f4c4f71",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following question:}}$\n",
    "\n",
    " - What are the dimensions (the size) of the data?  [Type the Answer here]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3010f34",
   "metadata": {},
   "source": [
    "---\n",
    "**Useless Trivia Alert!**:\n",
    "\n",
    "These terms come from typewritters and old-old-old-school printers, respectively. Typewritters had a \"carriage\" that held the paper and moved to the left while you typed. When you got to the right edge of the paper, you hit the \"*carriage return*\" key and the whole carriage flew back (*returned*) to right with a loud clunk and advanced the paper down a line. To this day, the big fat important key on the right side of most keyboards still says \"return\".\n",
    "\n",
    "Old-school printers used long continuous \"fan fold\" sheets of paper (they could be literally hundreds of feet long) and had to be told to advance the paper one line with a \"*line feed*\" command. Once you were done printing, you ripped/cut your paper off the printer sort of like you do with aluminum foil or plastic wrap!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dc35edc",
   "metadata": {},
   "source": [
    "**Useful aside!:**\n",
    "`pandas` has very convenient functionality. For example, we can even copy data to the clipboard and read that in. \n",
    "\n",
    "Go to Wikipedia and copy the table of the [population of Burkina Faso by year](https://en.wikipedia.org/wiki/Demographics_of_Burkina_Faso). \n",
    "\n",
    "After that, you can read the data from Wikipedia Table into a data table (technically a `pandas` data frame) like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26df8b15",
   "metadata": {},
   "outputs": [],
   "source": [
    "cb = pd.read_clipboard()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce1bb610",
   "metadata": {},
   "outputs": [],
   "source": [
    "cb"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa0f17e0",
   "metadata": {},
   "source": [
    "How cool is that?!?!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0bdaac5",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions:}}$\n",
    "\n",
    " - What are the names of the columns of the data copied from Wikipedia? [Type the Answer here]\n",
    " - What is the name of the variable I used to save the data in Python? [Type the Answer here]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb468367",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ab10f4c",
   "metadata": {},
   "source": [
    "Okay, now back to the show. In addition to `display()`, we use can use data frame \"methods\". \n",
    "\n",
    "What is a \"method\"? Methods are things that an object, like our loaded datasets (technically a `pandas` data frame), can do. They are actions that an object can perform for you without any additional coding on your part!\n",
    "\n",
    "Methods are invoked using the following syntax `ObjectName.MethodName`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2821087d",
   "metadata": {},
   "source": [
    "One thing a data frame knows how to do is show you its first few rows with the `head()` method. This method returns the top (leading, or head of a data table):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa9b0eac",
   "metadata": {},
   "outputs": [],
   "source": [
    "myDataFromFile.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c04123f",
   "metadata": {},
   "source": [
    "Another method is `tail()`. This second method shows the last rows of the table:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dbf860e",
   "metadata": {},
   "outputs": [],
   "source": [
    "myDataFromFile.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9816a140",
   "metadata": {},
   "source": [
    "But how do you know what methods a given object has? Python's `dir()` function will give you a directory of any objects methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "806a1791",
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(myDataFromFile)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df88e707",
   "metadata": {},
   "source": [
    "HFS!!! Data frames know how to do a LOT! It's a bit overwhelming actually. \n",
    "\n",
    "We can ignore all the things that look like \\_\\_this\\_\\_ at the top. Scrolling the the others, the method called `describe()` looks promising. Let's see what it does!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc0d7259",
   "metadata": {},
   "outputs": [],
   "source": [
    "myDataFromFile.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b63a9f0f",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following question:}}$\n",
    "\n",
    " - Describe in your own words what the method describe returns of the data. Describe the measures the method returns.\n",
    " \n",
    " [Type the Answer here]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13282837",
   "metadata": {},
   "source": [
    "OMG, that was a good find!\n",
    "\n",
    "I also noticed a `hist` method. Could it even be possible that data frames know how to draw histograms of themselves?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14267424",
   "metadata": {},
   "outputs": [],
   "source": [
    "myDataFromFile.hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9b731e4",
   "metadata": {},
   "source": [
    "#### **NO WAY!!!!!**\n",
    "\n",
    "As you can see, our journey of learning to play with data is going to be part learning to code and part figuring how to use what's already out there!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "134b2879",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions:}}$\n",
    "\n",
    " - What are the titles of the two histograms in the figures created by the method `.hist`?  [Type the answer here]\n",
    " - How do the titles of the histograms relate to the data? [Type the answer here]\n",
    " - What are the values in the x-axis of the histograms? [Type the answer here]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af0152bb",
   "metadata": {},
   "source": [
    "#### More advanced plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b33b8b8",
   "metadata": {},
   "source": [
    "Okay, next we will practice making a plot using the fancy library called `seaborn`. Let's make a histogram with `seaborn`. `Seaborn` is a library that really just calls `matplotlib` functions, but it provides a way to use those functions that is easier than using them directly.\n",
    "\n",
    "It also by default generally makes prettier plots.\n",
    "\n",
    "Here's a histogram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31cd1654",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.histplot(myDataFromFile, multiple=\"stack\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63b4d508",
   "metadata": {},
   "source": [
    "The method `.hisplot` takes as inputs a data object (like `myDataFromFile`), but also it takes as input arguments. Arguments are also variables, that are passed to methods to provide additional requests. For example, above we asked for the two variables `A` and `B` to be stacked, to have the histograms plotted on top of eachother.\n",
    "\n",
    "`seaborn.histplot()` has many additional arguments. You can Google `seaborn.histplot()` to see what other possible arguments are. \n",
    "\n",
    "Alternatively, you can use python's `?` to open a new window that shows all the arguments that `.histplot()` has: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "973c141b",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.histplot?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0527f6f0",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions:}}$\n",
    "\n",
    " - report three arguments of `.hist`  [Type the answer here]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae498824",
   "metadata": {},
   "source": [
    "### The Kernel Density Estimate (KDE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd768b2c",
   "metadata": {},
   "source": [
    "Now let's make Kernel Density Estimate (KDE) plots of the distributions. KDEs are essentially smoothed versions of histograms (we can unpack more about exactly what these are later). They can give us a better visual represtation of the \"vibe\" of a distribution.\n",
    "\n",
    "`seaborn` has a method that automatically makes KDE plots: `.kdeplot()`.\n",
    "\n",
    "For the KDE plot, we we will plot each variable separatedly. We will also use the `color` argument in the second plot to set the curves apart:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf874e9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.kdeplot(myDataFromFile[\"VarA\"])\n",
    "sns.kdeplot(myDataFromFile[\"VarB\"], color=\"r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71b8c796",
   "metadata": {},
   "source": [
    "Here we can more clearly see the difference in means as compared to the histogram."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd2fd696",
   "metadata": {},
   "source": [
    "We can make the visualization more aethetically appealing by using some of the optional arguments to `seaborn.kdeplot()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c98599e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.kdeplot(myDataFromFile[\"VarA\"], color=\"b\", fill=True, alpha=0.2)\n",
    "sns.kdeplot(myDataFromFile[\"VarB\"], color=\"r\", fill=True, alpha=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a2727a9",
   "metadata": {},
   "source": [
    "The `color` argument is obvious. `fill` colors the area under the curve, and `alpha` make the fill transparent so you can see one curve through the other. Play around with these!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0057b87",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions:}}$\n",
    "\n",
    " - Make the same plot as above but increaset the transparency of the histograms to 0.35. How does it look \n",
    "    \n",
    "    [Type the answer using the cell below]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3754bed",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "27ccc1c8",
   "metadata": {},
   "source": [
    "### Let's see if we can write data to a file!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7d73a7c",
   "metadata": {},
   "source": [
    "Now maybe we can write a summary of the original data to a file so we could potentially share it with other. What we'll do is use the `describe()` method again, but this time we'll assign it to new data frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4013b1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "mySummary = myDataFromFile.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86c01b9c",
   "metadata": {},
   "source": [
    "Let's just quickly that `mySummary` contains what we hope it does. The python command `print` will help us take a look at the summary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9143efc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mySummary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a836794b",
   "metadata": {},
   "source": [
    "See what we did above? Instead of returning the results of the method `.describe()` directly in the notebook output, we saved the output into a variable. We then used `print` to display the content of the variable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94c5c33a",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions:}}$\n",
    "\n",
    " - What is the name of the variable we saved the output of the method `.describe()` in? [Type the answer here]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e348abfc",
   "metadata": {},
   "source": [
    "Next let's write the variable to a file! Given that we are dealing with a table, we will save the variable in a `.csv` file. The variable has a method `.to_csv`, the method can be found by lurking the output of `dir(<varName>)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88d13ce8",
   "metadata": {},
   "outputs": [],
   "source": [
    "mySummary.to_csv(\"mySummary.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ac25680",
   "metadata": {},
   "source": [
    "Okay, but how do we know that worked? Easy! We'll read that file back in using `pandas.read_csv()` and see what it looks like!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dcaa0b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "mySummary2 = pd.read_csv(\"mySummary.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "236a4b26",
   "metadata": {},
   "source": [
    "And then we can look at it using `display()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06edca2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "display(mySummary2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2173c575",
   "metadata": {},
   "source": [
    "#### Sweet! We can now read and write data files. File I/O handled!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24c7fd18",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Final Report for this Tutorial.}}$\n",
    "\n",
    " - create a new repository under your user account on [github.com/yourUserName](github.com/yourUserName).\n",
    " - clone the repository locally on your computer (pick an ideal folder to do so, say, `~/git` or `~/code`)\n",
    " - move the file of jupyter notebookd for this tutorial in the folder of the repository cloned above. This will require using a combination of commands such as `mv` and `cp` and `cd` and `ls` (you can also do this by use your mouse, but make sure you are copying inside the proper ).\n",
    " - use `git add [file name]` Add the file you edited for this tutorial to the repository\n",
    " - use `git commit -am \"Your message here\"` to commit the file to the repository\n",
    " - push the local repository with the changes and the newly added file to the cloud using `git push [repository name]`\n",
    " - Submit the URL to the github repository on Canvas\n",
    " \n",
    " Note. Now on, the above is going to be required for every tutorial. We will always ask for you to report the URL of the tutorial with all the operations performed by you and the answers to the questions visible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "086f0cb9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}