Skip to content

Instantly share code, notes, and snippets.

@DuyLe22

DuyLe22/PY0101EN-4-1-ReadFile.ipynb

Created December 24, 2020 18:47
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save DuyLe22/7a29f8cf2abcee86fb626bbb4728fba9 to your computer and use it in GitHub Desktop.
Save DuyLe22/7a29f8cf2abcee86fb626bbb4728fba9 to your computer and use it in GitHub Desktop.
Download ZIP
Created on Skills Network Labs
Display the source blob
Display the rendered blob
Raw
PY0101EN-4-1-ReadFile.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<center>\n",
" <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/Logos/organization_logo/organization_logo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\" />\n",
"</center>\n",
"\n",
"# Reading Files Python\n",
"\n",
"Estimated time needed: **40** minutes\n",
"\n",
"## Objectives\n",
"\n",
"After completing this lab you will be able to:\n",
"\n",
"- Read text files using Python libraries\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2>Table of Contents</h2>\n",
"<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
" <ul>\n",
" <li><a href=\"download\">Download Data</a></li>\n",
" <li><a href=\"read\">Reading Text Files</a></li>\n",
" <li><a href=\"better\">A Better Way to Open a File</a></li>\n",
" </ul>\n",
" \n",
"</div>\n",
"\n",
"<hr>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"download\">Download Data</h2>\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('Example1.txt', <http.client.HTTPMessage at 0x7f791c108c18>)"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import urllib.request\n",
"url = 'https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/labs/example1.txt'\n",
"filename = 'Example1.txt'\n",
"urllib.request.urlretrieve(url, filename)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"--2020-12-24 13:29:51-- https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/labs/example1.txt\n",
"Resolving s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)... 67.228.254.196\n",
"Connecting to s3-api.us-geo.objectstorage.softlayer.net (s3-api.us-geo.objectstorage.softlayer.net)|67.228.254.196|:443... connected.\n",
"HTTP request sent, awaiting response... 200 OK\n",
"Length: 45 [text/plain]\n",
"Saving to: ‘/resources/data/Example1.txt’\n",
"\n",
"/resources/data/Exa 100%[===================>] 45 --.-KB/s in 0s \n",
"\n",
"2020-12-24 13:29:51 (18.0 MB/s) - ‘/resources/data/Example1.txt’ saved [45/45]\n",
"\n"
]
}
],
"source": [
"# Download Example file\n",
"\n",
"\n",
"!wget -O /resources/data/Example1.txt https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/labs/example1.txt"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"read\">Reading Text Files</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One way to read or write a file in Python is to use the built-in <code>open</code> function. The <code>open</code> function provides a <b>File object</b> that contains the methods and attributes you need in order to read, save, and manipulate the file. In this notebook, we will only cover <b>.txt</b> files. The first parameter you need is the file path and the file name. An example is shown as follow:\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%204/Images/ReadOpen.png\" width=\"500\" />\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" The mode argument is optional and the default value is <b>r</b>. In this notebook we only cover two modes: \n",
"\n",
"<ul>\n",
" <li><b>r</b> Read mode for reading files </li>\n",
" <li><b>w</b> Write mode for writing files</li>\n",
"</ul>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For the next example, we will use the text file <b>Example1.txt</b>. The file is shown as follow:\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%204/Images/ReadFile.png\" width=\"100\" />\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" We read the file: \n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# Read the Example1.txt\n",
"\n",
"example1 = \"Example1.txt\"\n",
"file1 = open(example1, \"r\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" We can view the attributes of the file.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The name of the file:\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Example1.txt'"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Print the path of file\n",
"\n",
"file1.name"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" The mode the file object is in:\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'r'"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Print the mode of file, either 'r' or 'w'\n",
"\n",
"file1.mode"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can read the file and assign it to a variable :\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'This is line 1 \\nThis is line 2\\nThis is line 3'"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Read the file\n",
"\n",
"FileContent = file1.read()\n",
"FileContent"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The <b>/n</b> means that there is a new line. \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can print the file: \n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is line 1 \n",
"This is line 2\n",
"This is line 3\n"
]
}
],
"source": [
"# Print the file with '\\n' as a new line\n",
"\n",
"print(FileContent)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The file is of type string:\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"str"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Type of file content\n",
"\n",
"type(FileContent)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is very important that the file is closed in the end. This frees up resources and ensures consistency across different python versions.\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"# Close file after finish\n",
"\n",
"file1.close()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2 id=\"better\">A Better Way to Open a File</h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Using the <code>with</code> statement is better practice, it automatically closes the file even if the code encounters an exception. The code will run everything in the indent block then close the file object. \n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is line 1 \n",
"This is line 2\n",
"This is line 3\n"
]
}
],
"source": [
"# Open file using with\n",
"\n",
"with open(example1, \"r\") as file1:\n",
" FileContent = file1.read()\n",
" print(FileContent)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The file object is closed, you can verify it by running the following cell: \n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Verify if the file is closed\n",
"\n",
"file1.closed"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" We can see the info in the file:\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is line 1 \n",
"This is line 2\n",
"This is line 3\n"
]
}
],
"source": [
"# See the content of file\n",
"\n",
"print(FileContent)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The syntax is a little confusing as the file object is after the <code>as</code> statement. We also don’t explicitly close the file. Therefore we summarize the steps in a figure:\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%204/Images/ReadWith.png\" width=\"500\" />\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We don’t have to read the entire file, for example, we can read the first 4 characters by entering three as a parameter to the method **.read()**:\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is line 1\n"
]
}
],
"source": [
"# Read first four characters\n",
"\n",
"with open(example1, \"r\") as file1:\n",
" print(file1.read(14))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Once the method <code>.read(4)</code> is called the first 4 characters are called. If we call the method again, the next 4 characters are called. The output for the following cell will demonstrate the process for different inputs to the method <code>read()</code>:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This\n",
" is \n",
"line 1 \n",
"\n",
"This is line 2\n"
]
}
],
"source": [
"# Read certain amount of characters\n",
"\n",
"with open(example1, \"r\") as file1:\n",
" print(file1.read(4))\n",
" print(file1.read(4))\n",
" print(file1.read(7))\n",
" print(file1.read(15))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The process is illustrated in the below figure, and each color represents the part of the file read after the method <code>read()</code> is called:\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%204/Images/ReadChar.png\" width=\"500\" />\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Here is an example using the same file, but instead we read 16, 5, and then 9 characters at a time: \n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is line 1 \n",
"\n",
"This \n",
"is line 2\n"
]
}
],
"source": [
"# Read certain amount of characters\n",
"\n",
"with open(example1, \"r\") as file1:\n",
" print(file1.read(16))\n",
" print(file1.read(5))\n",
" print(file1.read(9))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can also read one line of the file at a time using the method <code>readline()</code>: \n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"first line: This is line 1 \n",
"\n"
]
}
],
"source": [
"# Read one line\n",
"\n",
"with open(example1, \"r\") as file1:\n",
" print(\"first line: \" + file1.readline())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can also pass an argument to <code> readline() </code> to specify the number of charecters we want to read. However, unlike <code> read()</code>, <code> readline()</code> can only read one line at most.\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is line 1 \n",
"\n",
"This is line 2\n",
"This \n"
]
}
],
"source": [
"with open(example1, \"r\") as file1:\n",
" print(file1.readline(20)) # does not read past the end of line\n",
" print(file1.read(20)) # Returns the next 20 chars\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" We can use a loop to iterate through each line: \n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Iteration 0 : This is line 1 \n",
"\n",
"Iteration 1 : This is line 2\n",
"\n",
"Iteration 2 : This is line 3\n"
]
}
],
"source": [
"# Iterate through the lines\n",
"\n",
"with open(example1,\"r\") as file1:\n",
" i = 0;\n",
" for line in file1:\n",
" print(\"Iteration\", str(i), \": \", line)\n",
" i = i + 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can use the method <code>readlines()</code> to save the text file to a list: \n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"# Read all lines and save as a list\n",
"\n",
"with open(example1, \"r\") as file1:\n",
" FileasList = file1.readlines()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Each element of the list corresponds to a line of text:\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'This is line 3'"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Print the first line\n",
"\n",
"FileasList[0]\n",
"FileasList[2]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Print the second line\n",
"\n",
"FileasList[1]\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'This is line 3'"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Print the third line\n",
"\n",
"FileasList[2]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h2> Exercise </h2>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h4>Weather Data</h4>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Your friend, a rising star in the field of meterology, has called on you to write a script to perform some analysis on weather station data. Given below is a file \"resources/ex4.csv\", which contains some precipiation data for the month of June.\n",
"Each line in the file has the format - Date,Precipation (upto two decimal places). Note how the data is seperated using ','. The first row of the file contains headers and should be ignored.\n",
"\n",
"Your task is to complete the <code>getNAvg</code> function that computes a simple moving average for N days for the precipiation data, where N is a parameter. Your function should return a list of moving averages for the given data. \n",
"\n",
"The formula for a k day moving average over a series - $n_{0},n_{2},n_{3}....n_{m}$is:\n",
"\\begin{align}\n",
"M_{i} = M_{i-1} + \\frac{n_{i} - n_{i-k}}{k}, \\text{for i = k to m }\n",
"\\\\ \\text{where $M_{i}$ is the moving average}\n",
"\\end{align}\n",
"The skeleton code has been provided below. Edit only the required function.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\n",
"- Each line of the file has a '\\n' char which should be removed\n",
"- The lines in the file are read as strings and need to be typecasted to floats\n",
"- For a k day moving average, The data points for the last k days must be known\n",
" \n",
"```\n",
"\n",
"</details>\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"--2020-12-24 14:34:23-- https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%204/ex4.csv\n",
"Resolving cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud (cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud)... 169.63.118.104\n",
"Connecting to cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud (cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud)|169.63.118.104|:443... connected.\n",
"HTTP request sent, awaiting response... 200 OK\n",
"Length: 718 [text/csv]\n",
"Saving to: ‘ex4.csv’\n",
"\n",
"ex4.csv 100%[===================>] 718 --.-KB/s in 0s \n",
"\n",
"2020-12-24 14:34:24 (2.57 MB/s) - ‘ex4.csv’ saved [718/718]\n",
"\n"
]
}
],
"source": [
"##Download the file \n",
"\n",
"!wget https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%204/ex4.csv"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"statData =\"ex4.csv\"\n",
"\n",
"def getNAvg(file,N):\n",
" \"\"\"\n",
" file - File containting all the raw weather station data\n",
" N - The number of days to compute the moving average over\n",
" \n",
" Return a list of containg the moving average of all data points\n",
" \"\"\"\n",
" with open(\"ex4.csv\") as file:\n",
" newfile = []\n",
" moving_avg = []\n",
" next(file) \n",
" for line in file:\n",
" line = line.rstrip(\"\\n\")\n",
" line = float(line.split(',')[1])\n",
" newfile.append(line)\n",
" i = 0\n",
" window_size = N\n",
" while i < len(newfile)-window_size+1:\n",
" this_window = newfile[i:i+window_size]\n",
" window_avg = sum(this_window)/window_size\n",
" moving_avg.append(window_avg)\n",
" i += 1\n",
" return moving_avg\n",
"\n",
"def plotData(mean,N):\n",
" \"\"\" \n",
" mean - series to plot\n",
" N - parameter for legend\n",
" Plots running averages \n",
" \n",
" \"\"\"\n",
" mean = [round(x,3) for x in mean]\n",
" plt.plot(mean,label=str(N) + ' day average')\n",
" plt.xlabel('Day')\n",
" plt.ylabel('Precipiation')\n",
" plt.legend()\n",
" \n",
"\n",
" \n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Once you have finished, you can you use the block below to plot your data\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plotData(getNAvg(statData,1),1)\n",
"plotData([0 for x in range(1,5)]+ getNAvg(statData,5),5)\n",
"plotData([0 for x in range(1,7)]+ getNAvg(statData,7),7)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can use the code below to verify your progress -\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"getNAvg : \n",
"Test Passed\n"
]
}
],
"source": [
"avg5 =[4.18,4.78,4.34,4.72,5.48,5.84,6.84,6.76,6.74,5.46,4.18,2.74,2.52,2.02,2.16,2.82,2.92,4.36,4.74,5.12,5.34,6.4,6.56,6.1,5.74,5.62,4.26]\n",
"avg7 =[4.043,4.757,5.071,5.629,6.343,5.886,6.157,5.871,5.243,4.386,3.514,2.714,2.586,2.443,2.571,3.643,4.143,4.443,4.814,5.6,6.314,6.414,5.429,5.443,4.986]\n",
"\n",
"def testMsg(passed):\n",
" if passed:\n",
" return 'Test Passed'\n",
" else :\n",
" return ' Test Failed'\n",
"\n",
"print(\"getNAvg : \")\n",
"try:\n",
" sol5 = getNAvg(statData,5)\n",
" sol7 = getNAvg(statData,7)\n",
" \n",
" if(len(sol5)==len( avg5) and (len(sol7)==len(avg7))):\n",
" err5 = sum([abs(avg5[index] - sol5[index])for index in range(len(avg5))])\n",
" err7 = sum([abs(avg7[index] - sol7[index])for index in range(len(avg7))])\n",
" print(testMsg((err5 < 1) and (err7 <1)))\n",
" \n",
" else:\n",
" print(testMsg(false))\n",
"except NameError as e: \n",
" print('Error! Code: {c}, Message: {m}'.format(c = type(e).__name__, m = str(e)))\n",
"except:\n",
" print(\"An error occured. Recheck your function\")\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<details><summary>Click here for the solution</summary>\n",
"\n",
"```python\n",
"import matplotlib.pyplot as plt\n",
"\n",
"statData =\"ex4.csv\"\n",
"\n",
"def getNAvg(file,N):\n",
" \"\"\"\n",
" file - File containting all the raw weather station data\n",
" N - The number of days to compute the moving average over\n",
" \n",
" Return a list of containg the moving average of all data points\n",
" \"\"\"\n",
" row = 0 # keep track of rows\n",
" lastN = [] # keep track of last N points\n",
" mean = [0] # running avg\n",
" \n",
" \n",
" with open(file,\"r\") as rawData: \n",
" for line in rawData:\n",
" if (row == 0): # Ignore the headers\n",
" row = row + 1\n",
" continue\n",
" \n",
" line = line.strip('\\n')\n",
" lineData = float(line.split(',')[1])\n",
" \n",
" if (row<=N): \n",
" lastN.append(lineData)\n",
" mean[0] = (lineData + mean[0]*(row-1))/row\n",
" else:\n",
" mean.append( mean[row - N -1]+ (lineData - lastN[0])/N)\n",
" lastN = lastN[1:]\n",
" lastN.append(lineData)\n",
" \n",
" row = row +1 \n",
" return mean\n",
" \n",
"def plotData(mean,N):\n",
" \"\"\" Plots running averages \"\"\"\n",
" mean = [round(x,3) for x in mean]\n",
" plt.plot(mean,label=str(N) + ' day average')\n",
" plt.xlabel('Day')\n",
" plt.ylabel('Precipiation')\n",
" plt.legend()\n",
" \n",
"\n",
" \n",
"plotData(getNAvg(statData,1),1)\n",
"plotData ([0 for x in range(1,5)]+ getNAvg(statData,5),5 )\n",
"plotData([0 for x in range(1,7)] + getNAvg(statData,7),7)\n",
"\n",
" \n",
"```\n",
"\n",
"</details>\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"ename": "AttributeError",
"evalue": "'_io.TextIOWrapper' object has no attribute 'rea'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-17-32c17ccaa356>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;34m=\u001b[0m\u001b[0;34m\"ex4.csv\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mrawData\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mrawData\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrea\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mAttributeError\u001b[0m: '_io.TextIOWrapper' object has no attribute 'rea'"
]
}
],
"source": [
"file =\"ex4.csv\"\n",
"with open(file,\"r\") as rawData: \n",
" rawData.rea"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<div class=\"alert alert-success\">\n",
" Note: Files with sets of data seperated using ',' or other charecters are called '.csv' files.\n",
" They are a very common way to store data. Usually when dealing with them, An external library is used that does the nitpicky tasks for you. In fact, There are numerous libraries for statistical functions to. You will learn about such libraries later in the course. \n",
"</div>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<hr>\n",
"<h2>The last exercise!</h2>\n",
"<p>Congratulations, you have completed your first lesson and hands-on lab in Python. However, there is one more thing you need to do. The Data Science community encourages sharing work. The best way to share and showcase your work is to share it on GitHub. By sharing your notebook on GitHub you are not only building your reputation with fellow data scientists, but you can also show it off when applying for a job. Even though this was your first piece of work, it is never too early to start building good habits. So, please read and follow <a href=\"https://cognitiveclass.ai/blog/data-scientists-stand-out-by-sharing-your-notebooks/\" target=\"_blank\">this article</a> to learn how to share your work.\n",
"<hr>\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Author\n",
"\n",
"<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\" target=\"_blank\">Joseph Santarcangelo</a>\n",
"\n",
"## Other contributors\n",
"\n",
"<a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>\n",
"\n",
"## Change Log\n",
"\n",
"| Date (YYYY-MM-DD) | Version | Changed By | Change Description |\n",
"| ----------------- | ------- | ------------- | --------------------------------------------------------- |\n",
"| 2020-09-30 | 1.2 | Malika Singla | Weather Data dataset link added |\n",
"| 2020-09-30 | 1.1 | Arjun Swani | Added exericse \"Weather Data\" |\n",
"| 2020-09-30 | 1.0 | Arjun Swani | Added blurbs about closing files and read() vs readline() |\n",
"| 2020-08-26 | 0.2 | Lavanya | Moved lab to course repo in GitLab |\n",
"| | | | |\n",
"| | | | |\n",
"\n",
"<hr/>\n",
"\n",
"## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python",
"language": "python",
"name": "conda-env-python-py"
},
"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.6.12"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment