004_comission/max015/T10/T10/CDS1001T10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CDS1001 Tutorial 10 Report"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Input your name and student ID in the cell below (<font color='red'>if a cell is not in edit mode, double click it</font>):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your name: \n",
    "\n",
    "Your student ID:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Objectives:\n",
    "- Understand the basic process of acquiring and exploring data \n",
    "- Be able to understand and apply the use of ``csv`` package to process CSV  files automatically\n",
    "- Be able to understand and apply the use of ``statistics`` package to obtain summary statistics of data\n",
    "- Be able to understand and apply the use of ``matlplotlib`` package to draw basic charts for data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Instructions for the report**:\n",
    "* Follow Section 1 and Section 2 of the tutorial instruction to launch Python IDLE through Anaconda Navigation.\n",
    "* Refer to Section 2.2 of the tutorial instruction to open tutorial 10 report\n",
    "* Complete Parts 1-2 led by the lecturer\n",
    "* Follow Section 3 of the tutorial instruction to save the report and zip the report folder. The zip file is named as CDS1001T10Report{your student_id}.zip (e.g., if student_id is 1234567, then the zip file's name is CDS1001T10Report1234567.zip). <font color='red'>The zip file needs to include the following files:\n",
    "    - an .ipynb file of this tutorial report    \n",
    "    - image files of flowcharts or screenshots used in this tutorial report </font>       \n",
    "* Submit the zip file of the report folder to the Moodle. The submission due date is **<font color='red'>28 Nov 2023, 11:55PM</font>**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 1 Acquiring Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.1. Follow Slide 10 of Week 11 Lecture to create a csv file, which can contain any data but shall be different from the one in the slide. Copy the csv file in the cell below: (1 point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>Edit this cell to copy the newly created csv file which shall be different from the one in Slide 10. </font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2. Write and execute codes for the following questions 1-7. (14 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question 1. How would you obtain a Reader object for a csv file example.csv and store it in a variable ``rd``?  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Write your code here:\n",
    "import csv\n",
    "\n",
    "exampleFile = open('example.csv')\n",
    "rd = csv.reader(exampleFile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question 2. How would you retrieve the data in the csv file and store the data in a list variable ``data``?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['4/5/2014 13:34', 'Apples', '73', '4.5'], ['4/5/2014 3:41', 'Cherries', '85', '2.5'], ['4/6/2014 12:46', 'Pears', '14', '1.5'], ['4/8/2014 8:59', 'Oranges', '52', '5.5'], ['4/10/2014 2:07', 'Apples', '152', '3.5'], ['4/10/2014 18:10', 'Bananas', '23', '4.4'], ['4/10/2014 2:40', 'Strawberries', '98', '2.2']]\n"
     ]
    }
   ],
   "source": [
    "#Write your code here:\n",
    "data = list(rd)\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question 3. How would you retrieve and print the data at a row 3 and column 4 of the csv file?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5\n"
     ]
    }
   ],
   "source": [
    "#Write your code here:\n",
    "\n",
    "print(data[2][3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question 4. How would you traverse all the values of the csv file in a for loop?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4/5/2014 13:34 Apples 73 4.5 \n",
      "4/5/2014 3:41 Cherries 85 2.5 \n",
      "4/6/2014 12:46 Pears 14 1.5 \n",
      "4/8/2014 8:59 Oranges 52 5.5 \n",
      "4/10/2014 2:07 Apples 152 3.5 \n",
      "4/10/2014 18:10 Bananas 23 4.4 \n",
      "4/10/2014 2:40 Strawberries 98 2.2 \n"
     ]
    }
   ],
   "source": [
    "#Write your code here:\n",
    "\n",
    "for row in data:\n",
    "  for col in row:\n",
    "    print(str(col), end=' ')\n",
    "  print()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question 5. How would you write a row of numbers, '4/11/2014 12:44', 'watermelon', 100, 7.8, to a new csv file named 'new-example.csv'?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Write your code here:\n",
    "\n",
    "outputFile = open('new-example.csv', 'w', newline='')\n",
    "outputWriter = csv.writer(outputFile)\n",
    "outputWriter.writerow(['4/11/2014 12:44', 'watermelon', 100, 7.8])\n",
    "outputFile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question 6. How would you obtain a DictReader object for the csv file example.csv with header names equal to 'date', 'product', 'quantity', 'price', and store it in a variable ``rd``?  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Write your code here:\n",
    "\n",
    "exampleFile = open('example.csv')\n",
    "rd = csv.DictReader(exampleFile, ['date', 'product', 'quantity', 'price'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Question 7. How would you write the data to a new csv file named new-example2.csv with the header?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#Write your code here:\n",
    "\n",
    "outputFile = open('new-example2.csv', 'w', newline='')\n",
    "outputDictWriter = csv.DictWriter(outputFile, ['date', 'product', 'quantity', 'price'])\n",
    "outputDictWriter.writeheader()\n",
    "outputDictWriter.writerow({'date': 'Alice', 'product': 'grape', 'quantity': 20, 'price': 99.9})\n",
    "outputFile.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.4. Removing the Header from CSV Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say you have the boring job of removing the first line from several hundred CSV files with filenames starting with 'NAICS'. Maybe you’ll be feeding them into an automated process that requires just the data and not the headers at the top of the columns. You could open each file in Excel, delete the first row, and resave the file—but that would take hours. Let’s write a program to do it instead.\n",
    "\n",
    "The program will need to open every file with the .csv extension and with the filename starting with 'NAICS' in the current working directory, read in the contents of the file, and rewrite the contents without the first row to a file with 'headerRemoved' added to the file name. This will replace the old contents of the CSV file with the new, headless contents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 1: What is the algorithm to automate this work? What are the data structures needed? How are you going to write the code? (5 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>Edit this cell to answer the question above. </font>\n",
    "\n",
    "Algorithm:\n",
    "  - list all the CSV files in the current directory\n",
    "  - ignoring the first line, read in the content of the files.\n",
    "  - Write the contents, skipping the first line, to a new csv file\n",
    "\n",
    "Data Structures:\n",
    "  - Use list to store the values\n",
    "\n",
    "Code:\n",
    "  - loop over a list of fields from os.listdir(), ignore the file not ended with `csv`\n",
    "  - create a csv reader object and read the content of the files\n",
    "  - use a flag variable isFirstRow to indicate whether the line should skip\n",
    "  - create a csv writer object to write the read-in data to the new file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 2: Follow the steps below to write the code:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 1: Obtain a list of names of files in the current working directory (2 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing your program needs to do is to execute the code in the cell below, which uses listdir() method in os module to obtain a list of names of all the files in the current working directory, and stored the list in variable file_names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['output2.csv', 'NAICS_data_4610.csv', 'NAICS_data_7388.csv', 'NAICS_data_2092.csv', 'NAICS_data_7427.csv', 'NAICS_data_5341.csv', 'NAICS_data_5899.csv', 'NAICS_data_1952.csv', 'NAICS_data_4436.csv', 'task2.py', 'NAICS_data_1218.csv', 'NAICS_data_8015.csv', 'NAICS_data_8085.csv', 'NAICS_data_9066.csv', 'reset.sh', 'NAICS_data_3237.csv', 'NAICS_data_9250.csv', 'NAICS_data_1048.csv', 'NAICS_data_7102.csv', 'NAICS_data_8545.csv', 'NAICS_data_4125.csv', 'NAICS_data_1814.csv', 'NAICS_data_6842.csv', 'NAICS_data_9103.csv', 'NAICS_data_3144.csv', 'NAICS_data_5060.csv', 'NAICS_data_9825.csv', '.ipynb_checkpoints', 'NAICS_data_8397.csv', 'NAICS_data_2828.csv', 'NAICS_data_4699.csv', 'images', 'NAICS_data_5992.csv', '.DS_Store', 'NAICS_data_1889.csv', 'NAICS_data_2993.csv', 'NAICS_data_7830.csv', 'NAICS_data_7845.csv', 'NAICS_data_2346.csv', 'NAICS_data_3044.csv', 'NAICS_data_2066.csv', 'NAICS_data_6329.csv', 'NAICS_data_4213.csv', 'NAICS_data_7338.csv', 'task2_part2.py', 'NAICS_data_7226.csv', 'NAICS_data_2988.csv', 'CDS1001T10.ipynb', 'NAICS_data_9139.csv', 'NAICS_data_8196.csv', 'NAICS_data_5890.csv', 'NAICS_data_8760.csv', 'NAICS_data_3075.csv', 'rates1.csv', 'NAICS_data_3495.csv', 'rates2.csv', 'NAICS_data_1817.csv', 'task2_2_2_task3.py', 'NAICS_data_2799.csv', 'NAICS_data_9834.csv', 'NAICS_data_1657.csv', 'NAICS_data_2994.csv', 'NAICS_data_6493.csv', 'NAICS_data_3197.csv', 'NAICS_data_7677.csv', 'NAICS_data_8832.csv', 'NAICS_data_5631.csv', 'NAICS_data_7833.csv', 'NAICS_data_6397.csv', 'NAICS_data_8499.csv', 'NAICS_data_7535.csv', 'NAICS_data_4938.csv', 'NAICS_data_8700.csv', 'NAICS_data_1751.csv', 'NAICS_data_8131.csv', 'NAICS_data_7642.csv', 'NAICS_data_5364.csv', 'NAICS_data_4215.csv', 'example.csv', 'NAICS_data_2183.csv', 'NAICS_data_9986.csv', 'NAICS_data_6161.csv', 'NAICS_data_7765.csv', 'NAICS_data_9165.csv', 'NAICS_data_5092.csv', 'new-example2.csv', '.gitignore', 'rates3.csv', 'NAICS_data_8522.csv', 'NAICS_data_1973.csv', 'NAICS_data_4031.csv', 'NAICS_data_4896.csv', 'NAICS_data_7028.csv', 'NAICS_data_6904.csv', 'NAICS_data_6700.csv', 'NAICS_data_7383.csv', 'NAICS_data_6637.csv', 'new-example.csv', 'NAICS_data_6335.csv', 'NAICS_data_3073.csv', 'NAICS_data_2427.csv', 'NAICS_data_6181.csv', 'NAICS_data_2648.csv', 'NAICS_data_3494.csv', 'NAICS_data_7138.csv', 'NAICS_data_5305.csv', 'NAICS_data_8749.csv', 'NAICS_data_3731.csv', 'NAICS_data_4329.csv', 'NAICS_data_2959.csv', 'NAICS_data_4618.csv', 'NAICS_data_9448.csv', 'NAICS_data_7913.csv', 'NAICS_data_8403.csv', 'task1.py', 'NAICS_data_4525.csv', 'NAICS_data_9012.csv']\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "file_names = os.listdir()\n",
    "print(file_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 2: Loop Through Each CSV File and Edit It (24 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code below, write a for loop through each file name in file_names, if the file name starts with 'NAICS' and ends with \".csv\", do the followings:\n",
    "- (1) Create an empty list named csvRows to store rows beyond the first row of the CSV file\n",
    "- (2) Create a CSV reader object \n",
    "- (3) Write a for loop to read each row of the CSV file, and for each row, if it is not the first row, append it to the list csvRows\n",
    "- (4) create a CSV writer object for a new CSV file with its file name equal to 'headerRemoved'+file_name\n",
    "- (5) Write a for loop to write each row in csvRows to the new csv file\n",
    "- (6) Close the new CSV file and the oririnal CSV file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NAICS_data_4610.csv\n",
      "NAICS_data_7388.csv\n",
      "NAICS_data_2092.csv\n",
      "NAICS_data_7427.csv\n",
      "NAICS_data_5341.csv\n",
      "NAICS_data_5899.csv\n",
      "NAICS_data_1952.csv\n",
      "NAICS_data_4436.csv\n",
      "NAICS_data_1218.csv\n",
      "NAICS_data_8015.csv\n",
      "NAICS_data_8085.csv\n",
      "NAICS_data_9066.csv\n",
      "NAICS_data_3237.csv\n",
      "NAICS_data_9250.csv\n",
      "NAICS_data_1048.csv\n",
      "NAICS_data_7102.csv\n",
      "NAICS_data_8545.csv\n",
      "NAICS_data_4125.csv\n",
      "NAICS_data_1814.csv\n",
      "NAICS_data_6842.csv\n",
      "NAICS_data_9103.csv\n",
      "NAICS_data_3144.csv\n",
      "NAICS_data_5060.csv\n",
      "NAICS_data_9825.csv\n",
      "NAICS_data_8397.csv\n",
      "NAICS_data_2828.csv\n",
      "NAICS_data_4699.csv\n",
      "NAICS_data_5992.csv\n",
      "NAICS_data_1889.csv\n",
      "NAICS_data_2993.csv\n",
      "NAICS_data_7830.csv\n",
      "NAICS_data_7845.csv\n",
      "NAICS_data_2346.csv\n",
      "NAICS_data_3044.csv\n",
      "NAICS_data_2066.csv\n",
      "NAICS_data_6329.csv\n",
      "NAICS_data_4213.csv\n",
      "NAICS_data_7338.csv\n",
      "NAICS_data_7226.csv\n",
      "NAICS_data_2988.csv\n",
      "NAICS_data_9139.csv\n",
      "NAICS_data_8196.csv\n",
      "NAICS_data_5890.csv\n",
      "NAICS_data_8760.csv\n",
      "NAICS_data_3075.csv\n",
      "NAICS_data_3495.csv\n",
      "NAICS_data_1817.csv\n",
      "NAICS_data_2799.csv\n",
      "NAICS_data_9834.csv\n",
      "NAICS_data_1657.csv\n",
      "NAICS_data_2994.csv\n",
      "NAICS_data_6493.csv\n",
      "NAICS_data_3197.csv\n",
      "NAICS_data_7677.csv\n",
      "NAICS_data_8832.csv\n",
      "NAICS_data_5631.csv\n",
      "NAICS_data_7833.csv\n",
      "NAICS_data_6397.csv\n",
      "NAICS_data_8499.csv\n",
      "NAICS_data_7535.csv\n",
      "NAICS_data_4938.csv\n",
      "NAICS_data_8700.csv\n",
      "NAICS_data_1751.csv\n",
      "NAICS_data_8131.csv\n",
      "NAICS_data_7642.csv\n",
      "NAICS_data_5364.csv\n",
      "NAICS_data_4215.csv\n",
      "NAICS_data_2183.csv\n",
      "NAICS_data_9986.csv\n",
      "NAICS_data_6161.csv\n",
      "NAICS_data_7765.csv\n",
      "NAICS_data_9165.csv\n",
      "NAICS_data_5092.csv\n",
      "NAICS_data_8522.csv\n",
      "NAICS_data_1973.csv\n",
      "NAICS_data_4031.csv\n",
      "NAICS_data_4896.csv\n",
      "NAICS_data_7028.csv\n",
      "NAICS_data_6904.csv\n",
      "NAICS_data_6700.csv\n",
      "NAICS_data_7383.csv\n",
      "NAICS_data_6637.csv\n",
      "NAICS_data_6335.csv\n",
      "NAICS_data_3073.csv\n",
      "NAICS_data_2427.csv\n",
      "NAICS_data_6181.csv\n",
      "NAICS_data_2648.csv\n",
      "NAICS_data_3494.csv\n",
      "NAICS_data_7138.csv\n",
      "NAICS_data_5305.csv\n",
      "NAICS_data_8749.csv\n",
      "NAICS_data_3731.csv\n",
      "NAICS_data_4329.csv\n",
      "NAICS_data_2959.csv\n",
      "NAICS_data_4618.csv\n",
      "NAICS_data_9448.csv\n",
      "NAICS_data_7913.csv\n",
      "NAICS_data_8403.csv\n",
      "NAICS_data_4525.csv\n",
      "NAICS_data_9012.csv\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "\n",
    "for file_name in file_names:\n",
    "    if file_name.startswith ('NAICS') and file_name.endswith('.csv'):\n",
    "        print(file_name)\n",
    "\n",
    "        #(1) Create an empty list named csvRows to store rows beyond the first row of the CSV file\n",
    "        csvRows = []\n",
    "\n",
    "        #(2) Create a CSV reader object named csv_reader\n",
    "        exampleFile = open(file_name)\n",
    "        csv_reader = csv.reader(exampleFile)\n",
    "\n",
    "        #(3) Write a for loop to read each row of the CSV file, and for each row, \n",
    "        # if it is not the first row, append it to the list csvRows\n",
    "        for row in csv_reader:\n",
    "          if (csv_reader.line_num > 1):\n",
    "            csvRows.append(row)\n",
    "\n",
    "        #(4) create a CSV writer object for a new CSV file with its file name equal to 'headerRemoved'+file_name\n",
    "        outputFile = open('headerRemoved'+file_name, 'w', newline='')\n",
    "        outputWriter = csv.writer(outputFile)\n",
    "\n",
    "        #(5) Write a for loop to write each row in csvRows to the new csv file\n",
    "        for row in csvRows:\n",
    "          outputWriter.writerow(row)\n",
    "\n",
    "        #(6) Close the new CSV file and the original CSV file\n",
    "        outputFile.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 3: Test the above codes, and paste the screenshots of any two newly created files in the cell below: (5 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>Edit this cell to illustrate the testing results, and paste the screenshots of any two newly created files. </font>\n",
    "\n",
    "![](./images/part1_task3_pic1.png)\n",
    "\n",
    "![](./images/part1_task3_pic2.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2 Exploring Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1. Write codes for the following tasks: (16 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  Task 1. Given a list y = [5.4, 8.0, 1.0, 6.3, 2.9, 7.4, 7.9, 9.8, 4.9, 7.4], write a code in the cell below to print the sum, the max value, the min value, the mean value, and the standard deviation of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum: 61.0\n",
      "Max: 9.8\n",
      "Min: 1.0\n",
      "Mean: 6.1000000000000005\n",
      "Standard Deviation: 2.627630956668848\n"
     ]
    }
   ],
   "source": [
    "import statistics\n",
    "\n",
    "y = [5.4, 8.0, 1.0, 6.3, 2.9, 7.4, 7.9, 9.8, 4.9, 7.4]\n",
    "\n",
    "# Calculate the sum\n",
    "sum_y = sum(y)\n",
    "\n",
    "# Calculate the max value\n",
    "max_y = max(y)\n",
    "\n",
    "# Calculate the min value\n",
    "min_y = min(y)\n",
    "\n",
    "# Calculate the mean value\n",
    "mean_y = statistics.mean(y)\n",
    "\n",
    "# Calculate the standard deviation\n",
    "std_dev_y = statistics.stdev(y)\n",
    "\n",
    "print(f\"Sum: {sum_y}\")\n",
    "print(f\"Max: {max_y}\")\n",
    "print(f\"Min: {min_y}\")\n",
    "print(f\"Mean: {mean_y}\")\n",
    "print(f\"Standard Deviation: {std_dev_y}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 2. Given a list y = [5.4, 8.0, 1.0, 6.3, 2.9, 7.4, 7.9, 9.8, 4.9, 7.4], write a code to plot it in a bar chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#edit code for task 2\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "y = [5.4, 8.0, 1.0, 6.3, 2.9, 7.4, 7.9, 9.8, 4.9, 7.4]\n",
    "\n",
    "x = range(len(y))\n",
    "plt.bar(x, y)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 3. Given a list y = [5.4, 8.0, 1.0, 6.3, 2.9, 7.4, 7.9, 9.8, 4.9, 7.4], write a code to plot it in a line chart in red."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#edit code for task 3\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "y = [5.4, 8.0, 1.0, 6.3, 2.9, 7.4, 7.9, 9.8, 4.9, 7.4]\n",
    "x = range(len(y))\n",
    "\n",
    "plt.plot(x, y, color='red')\n",
    "plt.xlabel('X-axis')\n",
    "plt.ylabel('Y-axis')\n",
    "plt.title('Line Chart of y')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 4. Given two list \n",
    "y1 = [5.4, 8.0, 1.0, 6.3, 2.9, 7.4, 7.9, 9.8, 4.9, 7.4] and \n",
    "y2 = [5.49, 7.58, 1.5, 6.74, 3.33, 7.17, 7.53, 10.18, 4.63, 6.91], \n",
    "\n",
    "write a code to plot it in a scatterplot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#edit code for task 1\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Lists y1 and y2\n",
    "y1 = [5.4, 8.0, 1.0, 6.3, 2.9, 7.4, 7.9, 9.8, 4.9, 7.4]\n",
    "y2 = [5.49, 7.58, 1.5, 6.74, 3.33, 7.17, 7.53, 10.18, 4.63, 6.91]\n",
    "\n",
    "# Create x-axis values (0 to len(y1)-1)\n",
    "x = range(len(y1))\n",
    "\n",
    "# Plotting the scatterplot\n",
    "plt.scatter(x, y1, color='red', label='y1')\n",
    "plt.scatter(x, y2, color='green', label='y2')\n",
    "\n",
    "# Customize the chart\n",
    "plt.xlabel('X-axis')\n",
    "plt.ylabel('Y-axis')\n",
    "plt.title('Scatterplot of y1 and y2')\n",
    "plt.legend()\n",
    "\n",
    "# Display the chart\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2. Exploring Shipping Rates\n",
    "\n",
    "Company FE would like to explore the trend of shipping rates based on the past 300-day historical data stored in a text file. The text file has one line that contains 300 float numbers separated by commas which represent shipping rates of 300 days. Accurate values of some shipping rates may be missing, for which -1 are placed in the file.\n",
    "\n",
    "We need to write a program to help company FE explore the shipping rates by computing the mean, max, min, and standard deviation of the shipping rates, and plotting a line chart for the shipping rates.\n",
    "\n",
    "<font color = 'red'> *Note that there are multiple files of data to be explored. Thus, the text file is obtained from input. For test files, there are rates1.csv, rates2.csv, rates3.csv available in the report folder.* </font>\n",
    "\n",
    "To fix each missing shipping rate, we will replace it with 1000 if it is a shipping rate of day 1, and with the shipping rate one day before, otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 1: If you use Excel to do this work, what will be the difficulties? (2 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>Edit this cell to answer the question above. </font>\n",
    "\n",
    "Using Excel, it is difficult to clean the data (e.g. -1 means missing data and need to be replaced by 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 2: What is the algorithm to automate this work? What are the data structures needed? How are you going to write the code? (5 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>Edit this cell to answer the question above. </font>\n",
    "\n",
    "Algorithm:\n",
    "  - open and load the csv file\n",
    "  - extract the data, and fix the missing data\n",
    "  - print the summary information\n",
    "  - plot the chart for the data\n",
    "\n",
    "Data structure:\n",
    "  - use list to store the fixed data\n",
    "\n",
    "Code:\n",
    "  - read the filename, \n",
    "  - open the csv file\n",
    "  - store the first row or the file in a list\n",
    "  - for each index t in the list:\n",
    "  - convert the t-th value of the list to a float number\n",
    "  - if t-th value is a negative value (i.e. -1)\n",
    "  - if t == 0, replace the value by 1000,\n",
    "  - otherwise, replace the value with previous value in the list\n",
    "  - use statistic module to print out the summary of the data set\n",
    "  - use matplotlib.pyplot to plot the line chart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 3: Follow the steps below to write the code:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 1: Read the file using CSV module (10 points)\n",
    "\n",
    "In the code block below, do the followings:\n",
    "(1) Import csv module;\n",
    "(2) Get the file name from the input\n",
    "(3) Create a CSV reader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['-1', '673.47', '744.41', '704.76', '718.06', '692.85', '704.05', '692.75', '739.4', '732.81', '756.83', '784.98', '807.2', '793.93', '766.57', '775.2', '788.97', '816.21', '767.83', '815.16', '759.82', '774.18', '795.44', '818.97', '775.37', '744.57', '751.59', '790.03', '742.49', '729.3', '704.74', '738.04', '703.2', '680.6', '681.79', '678.32', '643.37', '665.21', '614.56', '631.88', '645.72', '675.76', '625.81', '647.13', '650.58', '-1', '718.31', '724.1', '689.75', '691.71', '709.43', '674.4', '723.07', '745.85', '718.23', '736.67', '698.81', '683.05', '689.15', '678.74', '653.48', '652.63', '691.68', '675.45', '724.02', '737.07', '729.09', '744.02', '779.52', '760.09', '734.86', '754.33', '748.43', '759.47', '715.26', '743.61', '760.48', '752.54', '788.81', '734.52', '698.19', '708.66', '717.19', '735.28', '779.24', '721.97', '756.19', '706.22', '-1', '753.07', '763.02', '799.75', '781.01', '744.33', '714.74', '738.39', '689.59', '685.7', '663.96', '646.07', '644.37', '643.67', '608.42', '620.56', '588.84', '594.6', '603.99', '582.65', '560.5', '528.91', '580.9', '584.57', '553.33', '539.88', '575.78', '579.15', '628.24', '599.92', '624.69', '649.9', '649.61', '688.76', '727.88', '676.53', '660.71', '683.41', '703.47', '744.18', '746.87', '754.21', '780.05', '787.35', '806.55', '811.64', '852.33', '825.46', '876.28', '828.24', '805.17', '793.56', '772.56', '765.29', '773.88', '752.51', '734.59', '702.27', '739.3', '753.83', '743.29', '719.5', '761.43', '723.41', '742.7', '765.92', '786.33', '768.75', '793.86', '750.99', '727.7', '685.47', '669.85', '659.55', '703.59', '653.25', '711.96', '681.98', '677.87', '706.32', '720.86', '743.91', '761.19', '748.94', '769.29', '744.04', '720.32', '719.23', '754.39', '750.76', '752.79', '744.46', '770.7', '803.88', '771.91', '767.94', '719.75', '702.61', '738.57', '771.11', '766.99', '786.74', '788.61', '780.87', '759.66', '735.75', '706.2', '721.92', '676.99', '687.91', '734.19', '676.64', '663.2', '680.68', '703.68', '686.25', '737', '679.4', '659.43', '620.29', '627.75', '661.33', '620.19', '604.92', '629.29', '622.97', '661.69', '654.43', '693.18', '665.88', '710.59', '-1', '706.37', '665.79', '632.08', '660.09', '647.49', '615.36', '602.14', '648.26', '674.7', '651.35', '616.62', '578.14', '571.49', '601.53', '622.59', '586.08', '626.27', '610.34', '631.69', '589.17', '619.81', '645.11', '661.52', '662.13', '686.52', '722.29', '749.14', '709.92', '763.16', '775.74', '813.38', '841.75', '851.32', '838.43', '845.76', '885.49', '882.97', '875.9', '832.18', '792.7', '802.49', '794.12', '840.51', '785.33', '811.42', '792.27', '752.01', '800.42', '783.16', '805.19', '813.51', '841.47', '869.62', '893.71', '850.99', '882.9', '917.84', '890.2', '859.08', '834.28', '813.11', '791.48', '-1', '763.82', '727.2', '709.59', '727.67', '680.91', '706.69', '723.88', '762.86', '743.91', '742.96', '710.89', '724.81', '686.67', '718.21', '704.22', '679.56', '726.62']\n"
     ]
    }
   ],
   "source": [
    "#Edit this cell for Step 1:\n",
    "#(1) Import csv module;\n",
    "import csv\n",
    "\n",
    "#(2) Get the file name from the input\n",
    "file_name = input(\"please input filename of csv file: \")\n",
    "# file_name = 'rates3.csv'\n",
    "\n",
    "#(3) Create a CSV reader\n",
    "exampleFile = open(file_name)\n",
    "csv_reader = csv.reader(exampleFile)\n",
    "\n",
    "#(4) Store the first row of the csv file in a list named rates\n",
    "rates = list(csv_reader)[0]\n",
    "\n",
    "#print the rates\n",
    "print(rates)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 2: Extract Data and Fix Missing Data (6 points)\n",
    "\n",
    "The next part of the program will loop through each shipping rate in the CVS file, fix the data if needed, and append the data in a list\n",
    "\n",
    "(0) Define a list variable named rates with an empty initial value;\n",
    "(1) write a for loop to traverse each value of the CSV file;\n",
    "(2) for each value, if it is negative, then fix the value by replacing it with 1000 if it is a shipping rate of day 1, and with the shipping rate one day before, otherwise.\n",
    "(3) Add each (fixed) value to the list rates\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000, 673.47, 744.41, 704.76, 718.06, 692.85, 704.05, 692.75, 739.4, 732.81, 756.83, 784.98, 807.2, 793.93, 766.57, 775.2, 788.97, 816.21, 767.83, 815.16, 759.82, 774.18, 795.44, 818.97, 775.37, 744.57, 751.59, 790.03, 742.49, 729.3, 704.74, 738.04, 703.2, 680.6, 681.79, 678.32, 643.37, 665.21, 614.56, 631.88, 645.72, 675.76, 625.81, 647.13, 650.58, 1000, 718.31, 724.1, 689.75, 691.71, 709.43, 674.4, 723.07, 745.85, 718.23, 736.67, 698.81, 683.05, 689.15, 678.74, 653.48, 652.63, 691.68, 675.45, 724.02, 737.07, 729.09, 744.02, 779.52, 760.09, 734.86, 754.33, 748.43, 759.47, 715.26, 743.61, 760.48, 752.54, 788.81, 734.52, 698.19, 708.66, 717.19, 735.28, 779.24, 721.97, 756.19, 706.22, 1000, 753.07, 763.02, 799.75, 781.01, 744.33, 714.74, 738.39, 689.59, 685.7, 663.96, 646.07, 644.37, 643.67, 608.42, 620.56, 588.84, 594.6, 603.99, 582.65, 560.5, 528.91, 580.9, 584.57, 553.33, 539.88, 575.78, 579.15, 628.24, 599.92, 624.69, 649.9, 649.61, 688.76, 727.88, 676.53, 660.71, 683.41, 703.47, 744.18, 746.87, 754.21, 780.05, 787.35, 806.55, 811.64, 852.33, 825.46, 876.28, 828.24, 805.17, 793.56, 772.56, 765.29, 773.88, 752.51, 734.59, 702.27, 739.3, 753.83, 743.29, 719.5, 761.43, 723.41, 742.7, 765.92, 786.33, 768.75, 793.86, 750.99, 727.7, 685.47, 669.85, 659.55, 703.59, 653.25, 711.96, 681.98, 677.87, 706.32, 720.86, 743.91, 761.19, 748.94, 769.29, 744.04, 720.32, 719.23, 754.39, 750.76, 752.79, 744.46, 770.7, 803.88, 771.91, 767.94, 719.75, 702.61, 738.57, 771.11, 766.99, 786.74, 788.61, 780.87, 759.66, 735.75, 706.2, 721.92, 676.99, 687.91, 734.19, 676.64, 663.2, 680.68, 703.68, 686.25, 737.0, 679.4, 659.43, 620.29, 627.75, 661.33, 620.19, 604.92, 629.29, 622.97, 661.69, 654.43, 693.18, 665.88, 710.59, 1000, 706.37, 665.79, 632.08, 660.09, 647.49, 615.36, 602.14, 648.26, 674.7, 651.35, 616.62, 578.14, 571.49, 601.53, 622.59, 586.08, 626.27, 610.34, 631.69, 589.17, 619.81, 645.11, 661.52, 662.13, 686.52, 722.29, 749.14, 709.92, 763.16, 775.74, 813.38, 841.75, 851.32, 838.43, 845.76, 885.49, 882.97, 875.9, 832.18, 792.7, 802.49, 794.12, 840.51, 785.33, 811.42, 792.27, 752.01, 800.42, 783.16, 805.19, 813.51, 841.47, 869.62, 893.71, 850.99, 882.9, 917.84, 890.2, 859.08, 834.28, 813.11, 791.48, 1000, 763.82, 727.2, 709.59, 727.67, 680.91, 706.69, 723.88, 762.86, 743.91, 742.96, 710.89, 724.81, 686.67, 718.21, 704.22, 679.56, 726.62]\n"
     ]
    }
   ],
   "source": [
    "#Edit this cell for Step 2:\n",
    "#Write a for loop to traverse each index of the list rates, and for each index t:\n",
    "for t in range(0,len(rates)):\n",
    "  #convert rates[t] to a float number;\n",
    "  rates[t] = float(rates[t])\n",
    "  \n",
    "  if (rates[t] <0):\n",
    "    #if rates[t] is negative, then fix the value by replacing rates[t] with 1000 \n",
    "    rates[t] = 1000\n",
    "  if (rates[t]==0):\n",
    "    # if t is zero, and replacing rates[t] with ratse[t-1], otherwise.\n",
    "    rates[t] = rates[t-1]\n",
    "\n",
    "    \n",
    "#print the rates\n",
    "print(rates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 3: Print Summary Statistics (4 points)\n",
    "In the cell below, output mean, standard deviation, max, and min of shipping rates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max: 1000\n",
      "Min: 528.91\n",
      "Mean: 725.4327\n",
      "Standard Deviation: 80.36811707709964\n"
     ]
    }
   ],
   "source": [
    "#Edit this cell for Step 3:\n",
    "import statistics\n",
    "\n",
    "# Calculate the max value\n",
    "max_rates = max(rates)\n",
    "\n",
    "# Calculate the min value\n",
    "min_rates = min(rates)\n",
    "\n",
    "# Calculate the mean value\n",
    "mean_rates = statistics.mean(rates)\n",
    "\n",
    "# Calculate the standard deviation\n",
    "std_dev_rates = statistics.stdev(rates)\n",
    "\n",
    "print(f\"Max: {max_rates}\")\n",
    "print(f\"Min: {min_rates}\")\n",
    "print(f\"Mean: {mean_rates}\")\n",
    "print(f\"Standard Deviation: {std_dev_rates}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 4: Plot Line Chart (4 points)\n",
    "In the cell below, plot a line chart for the shipping rates with x label as 'day', and y label as 'rate'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Edit this cell for Step 4:\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = range(len(rates))\n",
    "\n",
    "plt.plot(x, rates, color='red')\n",
    "plt.xlabel('X-axis')\n",
    "plt.ylabel('Y-axis')\n",
    "plt.title('Line Chart of rates')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Task 4: Test the above codes for rates1.csv, rates2.csv, and rates3.csv (3 points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>Edit this cell to illustrate the testing results, and paste the screenshot of the line plot for rates1.csv. </font>\n",
    "\n",
    "![](./images/step4_task4_rate1.png)\n",
    "\n",
    "```bash\n",
    "Max: 1000\n",
    "Min: 398.26\n",
    "Mean: 652.0710666666666\n",
    "Standard Deviation: 99.32730165657784\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>Edit this cell to illustrate the testing results, and paste the screenshot of the line plot for rates2.csv. </font>\n",
    "\n",
    "![](./images/step4_task4_rate2.png)\n",
    "\n",
    "\n",
    "```bash\n",
    "Max: 1076.33\n",
    "Min: 498.94\n",
    "Mean: 845.1132\n",
    "Standard Deviation: 138.54090769194138\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>Edit this cell to illustrate the testing results, and paste the screenshot of the line plot for rates3.csv. </font>\n",
    "\n",
    "![](./images/step4_task4_rate3.png)\n",
    "\n",
    "```bash\n",
    "Max: 1000\n",
    "Min: 528.91\n",
    "Mean: 725.4327\n",
    "Standard Deviation: 80.36811707709964\n",
    "```\n"
   ]
  }
 ],
 "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}