Merge branch 'main' of https://gitlab.msu.edu/CMSE/data_science_bridge_curriculum

12dde6f1 · Edmond Anderson · 1ee79d15 · 1ff20b4b · 12dde6f1 · 12dde6f1
Commit 12dde6f1 authored 2 years ago by Edmond Anderson
--- a/Basic_Containers.ipynb
+++ b/Basic_Containers.ipynb
--- a/BigO_C++.ipynb
+++ b/BigO_C++.ipynb
--- a/Functions_in_Python.ipynb
+++ b/Functions_in_Python.ipynb
--- a/Loops.ipynb
+++ b/Loops.ipynb
--- a/Numpy_Sympy.ipynb
+++ b/Numpy_Sympy.ipynb
--- a/Pointers.ipynb
+++ b/Pointers.ipynb
--- a/References.ipynb
+++ b/References.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "fc73d74c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('answercheck.py', <http.client.HTTPMessage at 0x7fc9a8612220>)"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "##ANSWER##\n",
+    "#Install answercheck in current director\n",
+    "from urllib.request import urlretrieve\n",
+    "urlretrieve('https://raw.githubusercontent.com/colbrydi/jupytercheck/master/answercheck.py', filename='answercheck.py')\n",
+    "##ANSWER##"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c2a4f39",
+   "metadata": {},
+   "source": [
+    "# References\n",
+    "Understanding References and their purpose "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b78245b",
+   "metadata": {},
+   "source": [
+    "Understanding the Reference: \n",
+    "![Captain America Meme - Image found in Google Images from Know Your Meme](https://i.kym-cdn.com/entries/icons/mobile/000/017/204/CaptainAmerica1_zps8c295f96.jpg)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "A reference variable is an alias, that is, another name for an already existing variable. Think of a variable name as a label attached to the variable's location in memory. You can then think of a reference as a second label attached to that memory location. Therefore, you can access the contents of the variable through either the original variable name or the reference.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89c2fa92",
+   "metadata": {},
+   "source": [
+    "## Learning Goals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment\n",
+    "\n",
+    "Questions that test for the learning goals and allows students to evaluate if they truly understand the topics."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0234bfdc",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Based on the code below what will be the output of the variable meal:\n",
+    "\n",
+    "    string food = \"Pizza\";\n",
+    "    string &meal = food; \n",
+    "\n",
+    "    cout << meal;\n",
+    "\n",
+    "1. \"Pizza\"\n",
+    "2. \"food\"\n",
+    "3. nothing\n",
+    "4. error"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d030f312",
+   "metadata": {},
+   "source": [
+    "&#9989; **<span style=\"color:red\">Question:</span>**  Based on the code below, what should be done to change the value of the variable GPA without changing the variable directly:\n",
+    "\n",
+    "    #include <iostream>\n",
+    "    int main(){\n",
+    "        double GPA = 3.14;\n",
+    "        std::cout << \"My GPA is: \" << GPA;\n",
+    "        }\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "daaf2d04",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Put your answer here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21f9b14e",
+   "metadata": {},
+   "source": [
+    "Reference Variable In C++ in 6 minutes (https://youtu.be/NGKt3Xwlobg)\n",
+    "\n",
+    "References Materials (https://www.w3schools.com/cpp/cpp_references.asp)\n",
+    "\n",
+    "References Material (https://www.tutorialspoint.com/cplusplus/cpp_references.htm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "9cc2b34a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "CheckWarning: passed variable is <class 'int'> and not a numpy.matrix.\n",
+      "    Trying to convert to a array matrix using ```A = np.matrix(A)```.\n",
+      "\n",
+      "\n",
+      "CheckWarning: passed matrix is int64 and not <class 'numpy.float64'>...\n",
+      "    Trying to convert to float using ```A = A.astype(float)```.\n",
+      "\n",
+      "Testing [[4.]]\n",
+      "Answer seems to be correct\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from answercheck import checkanswer\n",
+    "checkanswer.vector(x,'2cab95d1b144d663bad1ce5c51020ae0')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by <<YOUR NAME HERE>>, Michigan State University  \n",
+    "As part of the Data Science Bridge Project \n",
+    "    \n",
+    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-nc/4.0/88x31.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
+%% Cell type:code id:fc73d74c tags:
+``` python
+##ANSWER##
+#Install answercheck in current director
+from urllib.request import urlretrieve
+urlretrieve('https://raw.githubusercontent.com/colbrydi/jupytercheck/master/answercheck.py', filename='answercheck.py')
+##ANSWER##
+```
+%% Output
+    ('answercheck.py', <http.client.HTTPMessage at 0x7fc9a8612220>)
+%% Cell type:markdown id:3c2a4f39 tags:
+# References
+Understanding References and their purpose
+%% Cell type:markdown id:2b78245b tags:
+Understanding the Reference:
+![Captain America Meme - Image found in Google Images from Know Your Meme](https://i.kym-cdn.com/entries/icons/mobile/000/017/204/CaptainAmerica1_zps8c295f96.jpg)
+%% Cell type:markdown id:71e867d9 tags:
+## Description
+A reference variable is an alias, that is, another name for an already existing variable. Think of a variable name as a label attached to the variable's location in memory. You can then think of a reference as a second label attached to that memory location. Therefore, you can access the contents of the variable through either the original variable name or the reference.
+%% Cell type:markdown id:89c2fa92 tags:
+## Learning Goals
+%% Cell type:markdown id:58ec20e8 tags:
+## Self Assessment
+Questions that test for the learning goals and allows students to evaluate if they truly understand the topics.
+%% Cell type:markdown id:0234bfdc tags:
+&#9989; **<span style="color:red">Question:</span>**  Based on the code below what will be the output of the variable meal:
+    string food = "Pizza";
+    string &meal = food;
+    cout << meal;
+1. "Pizza"
+2. "food"
+3. nothing
+4. error
+%% Cell type:markdown id:d030f312 tags:
+&#9989; **<span style="color:red">Question:</span>**  Based on the code below, what should be done to change the value of the variable GPA without changing the variable directly:
+    #include <iostream>
+    int main(){
+        double GPA = 3.14;
+        std::cout << "My GPA is: " << GPA;
+        }
+%% Cell type:code id:daaf2d04 tags:
+``` python
+#Put your answer here
+```
+%% Cell type:markdown id:5d237ca9 tags:
+## Training Materials
+%% Cell type:markdown id:21f9b14e tags:
+Reference Variable In C++ in 6 minutes (https://youtu.be/NGKt3Xwlobg)
+References Materials (https://www.w3schools.com/cpp/cpp_references.asp)
+References Material (https://www.tutorialspoint.com/cplusplus/cpp_references.htm)
+%% Cell type:code id:9cc2b34a tags:
+``` python
+from answercheck import checkanswer
+checkanswer.vector(x,'2cab95d1b144d663bad1ce5c51020ae0')
+```
+%% Output
+    CheckWarning: passed variable is <class 'int'> and not a numpy.matrix.
+        Trying to convert to a array matrix using ```A = np.matrix(A)```.
+    CheckWarning: passed matrix is int64 and not <class 'numpy.float64'>...
+        Trying to convert to float using ```A = A.astype(float)```.
+    Testing [[4.]]
+    Answer seems to be correct
+%% Cell type:markdown id:44b461a0 tags:
+---
+Written by <<YOUR NAME HERE>>, Michigan State University
+As part of the Data Science Bridge Project
+<a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc/4.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/">Creative Commons Attribution-NonCommercial 4.0 International License</a>.
--- a/Scope_C++.ipynb
+++ b/Scope_C++.ipynb
--- a/Whitespace_Indentation.ipynb
+++ b/Whitespace_Indentation.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "950c4fef",
+   "metadata": {},
+   "source": [
+    "# Whitespace Sensitivity"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "019e60ef",
+   "metadata": {},
+   "source": [
+    "Short Title: Indentation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c61cba51",
+   "metadata": {},
+   "source": [
+    "# Description"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55abe61f",
+   "metadata": {},
+   "source": [
+    "Whitespaces or indedentation act as the spaces at the very start or inside of a code for enhanced readibility in Python. It is used to designate a block of code inside of a program. Any code without indentation or white space is attached to a specific source file. Whitespaces tend to be sensitive due to their ability to completely effect the possibilities of an output of a code or interpretation of a statement ultimately causing an error to pop up.\n",
+    "\n",
+    "It is important to understand, whitespace must always be consistant throughout code. So if a programmer starts with 5 spaces, 5 space must be used throughout the remainder of the block of code or else a syntax error will not allow the code to be ran."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8796bb7",
+   "metadata": {},
+   "source": [
+    "# Examples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "410f3f67",
+   "metadata": {},
+   "source": [
+    "'' - space\n",
+    "\n",
+    "/t - tab"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "880c1d84",
+   "metadata": {},
+   "source": [
+    "# Learning Materials"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "dfad44a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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\n",
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"640\"\n",
+       "            height=\"360\"\n",
+       "            src=\"https://www.youtube.com/embed/vgefSv5k-o4?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x7ff3796ec7c0>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"vgefSv5k-o4\",width=640,height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50fdb729",
+   "metadata": {},
+   "source": [
+    "10 minutes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ae1c549",
+   "metadata": {},
+   "source": [
+    "# Self-Assessment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2e5459e",
+   "metadata": {},
+   "source": [
+    "Create a code that tests whitespace values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "80ee2cd9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "printable Value is:  \n",
+      "printable Value is:  \n",
+      "printable Value is:  \n",
+      "printable Value is:  \n",
+      "printable Value is:  \n",
+      "printable Value is:  \n"
+     ]
+    }
+   ],
+   "source": [
+    "#Put your answer here\n",
+    "# import string \n",
+    "import string \n",
+    "    \n",
+    "# An input string.\n",
+    "Sentence = \"What time does lunch begin at Shaw?\"\n",
+    "  \n",
+    "for i in Sentence:\n",
+    "      \n",
+    "    # determines if whitespace is found in code\n",
+    "    if i in string.whitespace:\n",
+    "          \n",
+    "        # Prints the number of whitespace values and its characters\n",
+    "        print(\"printable Value is: \" + i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "351205d1",
+   "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
+%% Cell type:markdown id:950c4fef tags:
+# Whitespace Sensitivity
+%% Cell type:markdown id:019e60ef tags:
+Short Title: Indentation
+%% Cell type:markdown id:c61cba51 tags:
+# Description
+%% Cell type:markdown id:55abe61f tags:
+Whitespaces or indedentation act as the spaces at the very start or inside of a code for enhanced readibility in Python. It is used to designate a block of code inside of a program. Any code without indentation or white space is attached to a specific source file. Whitespaces tend to be sensitive due to their ability to completely effect the possibilities of an output of a code or interpretation of a statement ultimately causing an error to pop up.
+It is important to understand, whitespace must always be consistant throughout code. So if a programmer starts with 5 spaces, 5 space must be used throughout the remainder of the block of code or else a syntax error will not allow the code to be ran.
+%% Cell type:markdown id:f8796bb7 tags:
+# Examples
+%% Cell type:markdown id:410f3f67 tags:
+'' - space
+/t - tab
+%% Cell type:markdown id:880c1d84 tags:
+# Learning Materials
+%% Cell type:code id:dfad44a7 tags:
+``` python
+from IPython.display import YouTubeVideo
+YouTubeVideo("vgefSv5k-o4",width=640,height=360, cc_load_policy=True)
+```
+%% Output
+    <IPython.lib.display.YouTubeVideo at 0x7ff3796ec7c0>
+%% Cell type:markdown id:50fdb729 tags:
+10 minutes
+%% Cell type:markdown id:4ae1c549 tags:
+# Self-Assessment
+%% Cell type:markdown id:a2e5459e tags:
+Create a code that tests whitespace values.
+%% Cell type:code id:80ee2cd9 tags:
+``` python
+#Put your answer here
+# import string
+import string
+# An input string.
+Sentence = "What time does lunch begin at Shaw?"
+for i in Sentence:
+    # determines if whitespace is found in code
+    if i in string.whitespace:
+        # Prints the number of whitespace values and its characters
+        print("printable Value is: " + i)
+```
+%% Output
+    printable Value is:
+    printable Value is:
+    printable Value is:
+    printable Value is:
+    printable Value is:
+    printable Value is:
+%% Cell type:code id:351205d1 tags:
+``` python
+```