diff --git a/BigO_C++.ipynb b/BigO_C++.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9bdd99dc5cb70891ace2e54a52da16f918fc47b2
--- /dev/null
+++ b/BigO_C++.ipynb
@@ -0,0 +1,422 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fc73d74c",
+ "metadata": {},
+ "outputs": [],
+ "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": [
+ "# Big O Notation\n",
+ "Quantifying the efficiency of a program by looking at the amount of time it takes to run and memory space it takes up."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2b78245b",
+ "metadata": {},
+ "source": [
+ "**_Optional_** Motivating picture: \n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "71e867d9",
+ "metadata": {},
+ "source": [
+ "## Description\n",
+ "We write many different algorithms when programming. As we run these programs more often and with larger amounts of data, it is important to be able to compare the efficiency of these programs with one another. Big O allows us to do this. There are two aspects of code Big O considers: Time and Space. \n",
+ "\n",
+ "Big O looks at the amount of time it takes a program to run. It also looks at the amount of memory space a program requires."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "58ec20e8",
+ "metadata": {},
+ "source": [
+ "## Self Assessment"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6b6725f1",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 1:</span>** Let's say you have a linear algorithm. Type its correct Big O notation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9c50d3cc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## Put your answer here"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7bc902d2",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [],
+ "source": [
+ "##ANSWER##\n",
+ "O(N)\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b0bcbd50",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from answercheck import checkanswer\n",
+ "checkanswer.vector(x,'2cab95d1b144d663bad1ce5c51020ae0')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38dd8bfb",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 2:</span>** What type of algorithm has a higher Big O value? (It requires more time and/or space than the others)\n",
+ "\n",
+ "1. Linear\n",
+ "2. Exponential\n",
+ "3. Quadratic\n",
+ "4. Binary Search"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0a7bd8a8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## Put your answer here"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "62bf095a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "##ANSWER##\n",
+ "2\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "67a669f6",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 3:</span>** What type of algorithm has to have an ordered container to be used?\n",
+ "\n",
+ "1. Linear\n",
+ "2. Exponential\n",
+ "3. Quadratic\n",
+ "4. Binary Search"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3b5de69d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## Put your answer here"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f5fb293c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "##ANSWER##\n",
+ "4\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49395163",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 4:</span>** If a program has multiple pieces of code with different run times, what Big O notation is used to represent the entire program run time? \n",
+ "\n",
+ "1. The largest run time from the code\n",
+ "2. The minimum code run time from the code\n",
+ "3. An average of all the code chunk run times\n",
+ "4. The sum of all the code chunk run times"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1ccb15b6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## Put your answer here"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cd1ea9c4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "##ANSWER##\n",
+ "1\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c12a3b73",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 5:</span>** What type of Big O example is the following code? (Answer in all lowercase text)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4ac7afad",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "valList = [1,2,3,4,5]\n",
+ "listSum = 0;\n",
+ "for x in valList:\n",
+ " listSum += x\n",
+ "\n",
+ "print(listSum)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ac0e0202",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## Put your answer here"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4b5e2b4c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "##ANSWER##\n",
+ "linear\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "99f869f7",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 7:</span>** What type of Big O example is the following code? (Answer in all lowercase text)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4e79ed15",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "valList = [1,2,3,4,5]\n",
+ "listSize = len(valList)\n",
+ "print(listSize)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "fbdbbc87",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## Put your answer here"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f6628cdd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "##ANSWER##\n",
+ "constant\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d237ca9",
+ "metadata": {},
+ "source": [
+ "## Training Materials\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b047470",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Read the following website:</span>** <br/> An introduction to what Big O notation is and a few types of notation you should be familiar with: <br/> <br/> https://towardsdatascience.com/introduction-to-big-o-notation-820d2e25d3fd"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "72ca96bc",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Watch the following video:</span>** <br/> Reviewing Big O notation, expanding on what you previously read, and going over examples of Big O notation:<br/>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "6ff70742",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " <iframe\n",
+ " width=\"100%\"\n",
+ " height=\"360\"\n",
+ " src=\"https://www.youtube.com/embed/__vX2sjlpXU?cc_load_policy=True\"\n",
+ " frameborder=\"0\"\n",
+ " allowfullscreen\n",
+ " ></iframe>\n",
+ " "
+ ],
+ "text/plain": [
+ "<IPython.lib.display.YouTubeVideo at 0x7f5f00d7ba00>"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import YouTubeVideo\n",
+ "YouTubeVideo(\"__vX2sjlpXU\",width=\"100%\", height=360, cc_load_policy=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "59d22056",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Click on the link below:</span>** <br/>\n",
+ "You do not need to read the entire article; rather, look at the first couple of Big O notations. These provide good code examples for each notation and an explanation of *why* they fall under a certain Big O notation.<br/><br/>\n",
+ "https://developerinsider.co/big-o-notation-explained-with-examples/"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9812391f",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Click on the link below:</span>** <br/>\n",
+ "**TIP:** In C++, you can see how complex different algorithms are by looking at their documentation. The function you are going to look at is the \"copy\" function. In C++, this function will copy the string (AKA text) from one container to another. <br/> <br/>\n",
+ "https://cplusplus.com/reference/string/string/copy/\n",
+ "<br/><br/>\n",
+ "Scroll down on the page to where it says \"Complexity\". Ask yourself the following questions: <br/>\n",
+ " - *What type of Big O search is this?* <br/>\n",
+ " - *What would be the notation?* <br/> <br/>\n",
+ "Then, click on the following link below and compare the \"at\" functions Complexity to that of the \"copy\" function. <br/><br/>\n",
+ "https://cplusplus.com/reference/string/string/at/"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "44b461a0",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "\n",
+ "Written by Jessica Parks, 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>."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6452d221",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "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
+}
diff --git a/Scope_C++.ipynb b/Scope_C++.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..bd97ce4354a8dd400cebdabbaf4e99f11876c45c
--- /dev/null
+++ b/Scope_C++.ipynb
@@ -0,0 +1,548 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "fc73d74c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "('answercheck.py', <http.client.HTTPMessage at 0x7fd334327910>)"
+ ]
+ },
+ "execution_count": 1,
+ "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": [
+ "# Scope\n",
+ "Recognizing where variables can be used in a program and where they cannot be used."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2b78245b",
+ "metadata": {},
+ "source": [
+ "**_Optional_** Motivating picture: \n",
+ "\n",
+ "(https://blogs.lse.ac.uk/impactofsocialsciences/files/2015/03/bridge-construction.jpg)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "71e867d9",
+ "metadata": {},
+ "source": [
+ "## Description\n",
+ "Scope is defined as when and where a variable is accessible in a program. There are different types of scope - different ways a variable can be accessed in a program. This document will only focus on two types of scope, Global scope and Local scope."
+ ]
+ },
+ {
+ "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": "4af35ce7",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 1:</span>** Which of the scope types is accessible to all of the program?\n",
+ "\n",
+ "1. Local Scope\n",
+ "2. Global Scope"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "15f43828",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "##ANSWER##\n",
+ "2\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3921c156",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 2:</span>** Where would you not see a local scope defined in a program?\n",
+ "\n",
+ "1. In a function\n",
+ "2. In a class\n",
+ "3. In a loop\n",
+ "4. Beginning of a program"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "c3dfd97d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "##ANSWER##\n",
+ "4\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "77bd1740",
+ "metadata": {},
+ "source": [
+ "**Use the code below to answer questions 3-5.** <br/>\n",
+ "**Hint:** The print statement is written as the following:\n",
+ "``` bash \n",
+ "std::cout<< YourTextHere <<std::endl; \n",
+ "```\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "12d2601a",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 3:</span>** What is printed at line 8?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "65583bcc",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "##ANSWER##\n",
+ "10\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "93d6fe2f",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 4:</span>** What is printed at line 15?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e5e975d1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "4"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "##ANSWER##\n",
+ "4\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "87a7ef55",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 5:</span>** If we were to print out **c** after the last yellow curly bracket, what would be its value?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "53254c28",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "##ANSWER##\n",
+ "10\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5024c8b7",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 6:</span>** What will be printed below?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1d37b9f3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 300\n",
+ "def func():\n",
+ " x = 200\n",
+ " print(x)\n",
+ "\n",
+ "\n",
+ "# print(x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "6c5c196b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "300"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "##ANSWER##\n",
+ "300\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0456a3c4",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 7:</span>** What will be printed below?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "f0e44800",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 300\n",
+ "def func():\n",
+ " x = 200\n",
+ " print(x)\n",
+ "\n",
+ "# func()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "51029b03",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "200"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "##ANSWER##\n",
+ "200\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6b48b0d0",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Question 8:</span>** How do you identify the scope of a variable in Python (As opposed to C++ syntax)?\n",
+ "\n",
+ "1. Using curly brackets {}\n",
+ "2. Using parantheses ()\n",
+ "3. Using indentation\n",
+ "4. Using the variable name"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "4f70eba5",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "##ANSWER##\n",
+ "3\n",
+ "##ANSWER##"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "9cc2b34a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# from answercheck import checkanswer\n",
+ "# checkanswer.vector(x,'2cab95d1b144d663bad1ce5c51020ae0')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a3fad10",
+ "metadata": {},
+ "source": [
+ "## Training Materials"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ea15c34b",
+ "metadata": {},
+ "source": [
+ "#### What is Scope?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "343e3b11",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Read the following website:</span>** https://www.educative.io/answers/what-is-scope <br>\n",
+ "**Note:** The website talks about where the scope is but not how to necessarily identify it in the code. When there are \"curly brackets\" or { }, the variables defined within this are considered **local** - in the case seen on the website, the following variable is local:\n",
+ "``` bash \n",
+ " string name = Bob\n",
+ "```\n",
+ "<br> \n",
+ "The video below will go more in depth about this, but this link will help first introduce you to Global and Local Scope."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b44650dd",
+ "metadata": {},
+ "source": [
+ "#### Introduction to Global and Local Scope in C++"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "b64de2b9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " <iframe\n",
+ " width=\"100%\"\n",
+ " height=\"360\"\n",
+ " src=\"https://www.youtube.com/embed/RTWHa8WEtYk?cc_load_policy=True\"\n",
+ " frameborder=\"0\"\n",
+ " allowfullscreen\n",
+ " ></iframe>\n",
+ " "
+ ],
+ "text/plain": [
+ "<IPython.lib.display.YouTubeVideo at 0x7fd334290520>"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import YouTubeVideo\n",
+ "YouTubeVideo(\"RTWHa8WEtYk\",width=\"100%\", height=360, cc_load_policy=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "560d9310",
+ "metadata": {},
+ "source": [
+ "#### Code Walkthrough of Scope in C++"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "3690ed8b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/jpeg": "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\n",
+ "text/html": [
+ "\n",
+ " <iframe\n",
+ " width=\"100%\"\n",
+ " height=\"360\"\n",
+ " src=\"https://www.youtube.com/embed/tXo7QyOGMBk?cc_load_policy=True\"\n",
+ " frameborder=\"0\"\n",
+ " allowfullscreen\n",
+ " ></iframe>\n",
+ " "
+ ],
+ "text/plain": [
+ "<IPython.lib.display.YouTubeVideo at 0x7fd334290d60>"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import YouTubeVideo\n",
+ "YouTubeVideo(\"tXo7QyOGMBk\",width=\"100%\", height=360, cc_load_policy=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e8ae5f06",
+ "metadata": {},
+ "source": [
+ "#### Scope in Python"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e9a0e12",
+ "metadata": {},
+ "source": [
+ "✅ **<span style=\"color:red\">Read the following website:</span>** https://www.w3schools.com/python/python_scope.asp <br>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "44b461a0",
+ "metadata": {},
+ "source": [
+ "---\n",
+ "\n",
+ "Written by Jessica Parks, 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
+}