Basic Containers and Functions

Basic_Containers.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3c2a4f39",
+   "metadata": {},
+   "source": [
+    "# Basic Containers\n",
+    "Understanding and Using Basic Containers in Python"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b78245b",
+   "metadata": {},
+   "source": [
+    "\n",
+    "![Google Python Symbol- Image found in the public domain](https://freesvg.org/img/387.png)\n",
+    "\n",
+    "https://freesvg.org/img/387.png\n",
+    "\n",
+    "Python Language Logo from Free SVG\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71e867d9",
+   "metadata": {},
+   "source": [
+    "## Description\n",
+    "Many times, in using python, there will be a need to store values. A common way to do so and store the values under a single variable is to use basic containers. This page will breakdown the common container types in Python. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec20e8",
+   "metadata": {},
+   "source": [
+    "## Self Assessment\n",
+    "\n",
+    "Click the following link to assess your knowledge on Basic Containers:\n",
+    "https://realpython.com/quizzes/pybasics-tuples-lists-dicts/ "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d237ca9",
+   "metadata": {},
+   "source": [
+    "## Training Materials\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21f9b14e",
+   "metadata": {},
+   "source": [
+    "Video Description (URL Link to video)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "deeec8f7",
+   "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/aBqTgR-gP3g?cc_load_policy=True\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.YouTubeVideo at 0x1cd12db60d0>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import YouTubeVideo\n",
+    "YouTubeVideo(\"aBqTgR-gP3g\",width=\"100%\", height=360, cc_load_policy=True)"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "08e8ef5c",
+   "metadata": {},
+   "source": [
+    "|Container Type|Mutable or Immutable|Initialization *Without* Values|Initializtion *With* Values|Adding Values to Container|Removing Values from Container|Modifying Values|Access Method|Notable Operations and Additional Information|\n",
+    "|---|---|---|---|---|---|---|---|---|\n",
+    "|**List**| Mutable |<ul><li>`a=list()` </li><li> `a=[]` </li></ul> | `a=['1', '2', '3']`|  <ul><li>` list.append(item) #Adds item to the end of the list` </li><li> ` list.insert(index, item) #Adds item to the specified index in the list`</li></ul>|`list.remove(item) #removes the first instance of 'item' from the list. If there is not such element, this will cause an error`|`>>> a[0] = 'cat'` <br> `>>> a` <br> `['cat', '2', '3']` |Access by index: <br> `>>> a[0]` <br> `1`|See webpage at http://www.linuxtopia.org/online_books/programming_books/python_programming/python_ch14s07.html for some helpful methods when dealing with lists.|\n",
+    "|**Dictionary**|Mutable| `student={}` | `>>> student={'name': 'John Doe', 'age': 22, 'college': 'MSU'}` | `>>> student['major']='Computer Science'` <br> `>>> student` <br> `{'name': 'John Doe', 'age': 22, 'college': 'MSU', 'major': 'Computer Science'}` | `del dictName[keyName] #This method removes all entries associated with the given key` | `>>> student['age'] = 23` <br> `>>> student` <br> `{'name': 'John Doe', 'age': 23, 'college': 'MSU', 'major': 'Computer Science'}`| Access by key word. Note that this key **must** be a string. <br> `>>>student['college']` <br> `MSU`| The 'in' keyword can be very helpful with dictionaries. Ex: <br><ul><li>`'k' in dict #Returns true if key 'k' is in dictionary dict`</li><li>`'k' not in dict #Returns true if key 'k' is not in dicitonary dict`</li><li>`for key in dict #This will iterate over all keys in dictionary dict`</li></ul> <br>See webpage at http://www.python-course.eu/python3_dictionaries.php for additional helpful methods and operations|\n",
+    "|**Set**|Mutable. However the objects contained within a set **must** be immutable. | `s=set()`|`s=set(['a','b','c'])` | `s.add(item)`|<ul><li> `set.discard(item) #If item is in the set, the item is removed, otherwise nothing happens` </li><li> `set.remove(item) #If item is in the set, the item is removed, otherwise raise a KeyError` </li><li> `set.pop() #Remove and return an arbitrary element from the set. If the set is empty, raise a KeyError` </li>| Sets are unordered, therefore indexing does not mean anything. To modify a set, you must directly add or remove elements. |`>>> set.pop() #This will remove and return an arbitrary element from the set`|Some helpful methods include:<ul><li>`difference()`</li><li>`intersection()`</li><li>`isdisjoint()`</li><li>`union()`</li></ul><br> See webpage at http://www.programiz.com/python-programming/set for additional helpful methods and operations|\n",
+    "| **Tuple** |Immutable|<ul><li>`t=()`</li><li> `t=tuple()`</li><ul>|<ul><li>1-tuple:<br>`t=('Hello',)`</li><li> 2-tuple:<br> `t=('Hello', 'Goodbye')`</li><ul>|N/A|N/A|N/A|`t=('Hello','Goodbye','Goodnight')`<ul><li>Access By Index: <br> `>>> t[0]` <br> `'Hello'` </li><br><li> Access By Slice <br> `>>>t[0:1:2]` <br> `('Hello','Goodbye')`</li></ul>|<ul><li>Packing and Unpacking</li><br><li>Tuple to List: `list(tupleName)`</li></ul>|\n",
+    "| **NumPy Array\\***|Mutable|`a=np.array([])`| `a=np.array([1,2,3,4,5])` | <ul><li>`np.insert(arrayName,index,values,axis) #Inserts a value for an array at the given index.` </li><li>`np.append(arrayName,value,axis) #Appends values to the end of an array.`</li></ul>|`np.array(array,index/indices,axis) #Returns a new array with the given index or array of indices deleted on the given axis`|`>>> a[4] = 12` <br> `array([ 1,  2,  3,  4, 12])` <br><br> For additional information on manipulating NumPy Arrays see the webpage at http://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html |<ul><li>Access By Index: <br> `>>> a[0] `<br>` 1 `</li><li>Access By Slice: <br> `>>> a[0:5:2] `<br> `array([1, 3, 5])` </li></ul><br>See webpage at http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html for further information about indexing of NumPy Arrays|See webpages at http://www.scipy-lectures.org/intro/numpy/array_object.html and https://docs.scipy.org/doc/numpy-dev/user/quickstart.html for additional information on NumPy Arrays|\n",
+    "    \n",
+    "\\*Use of the NumPy Array requires the NumPy Python Module. Assuming import statement is \"import numpy as np\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8bdbe577",
+   "metadata": {},
+   "source": [
+    "List – a data structure in Python that is a mutable ordered sequence of elements. \n",
+    "\tmy_list = [1, “world”, 5.9]\n",
+    "\n",
+    "Dictionary – a mutable data storage method which is used to store data values in key : value pairs. \n",
+    "\tmy_dict = {‘msu’: 1, ‘spartans’ : ‘green’, “mcdonel’ : ‘hall’}\n",
+    " \n",
+    "Tuple – used to store multiple items in a single variable.\n",
+    "\tmy_tuple = (“apple”. “bananas”, “cherry”, “strawberry”)\n",
+    "\n",
+    "NumPy Array – a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. \n",
+    "\timport numpy as np\n",
+    "\tarr = np.array(1, 2, 3, 4, 5, 6)\n",
+    "\n",
+    "\tprint(arr)\n",
+    "\n",
+    "\toutput: [1, 2, 3, 4, 5, 6]\n",
+    "\n",
+    "Array – a collection of items stored at contiguous memory locations. Values can be accessed by referring to an index number. \n",
+    "\tcars = [“bmw”, “jeep”, “toyota”, “kia”]\n",
+    "\n",
+    "\n",
+    "Map – a built-in function that allows the user to process and transform all the items in a container in an iterable(such as a list or dictionary without using a loop.\n",
+    "\t# Return double of n\n",
+    "def addition(n):\n",
+    "   \t\t return n + n\n",
+    "    \n",
+    "    # We double all numbers using map()\n",
+    "    numbers = (1, 2, 3, 4)\n",
+    "    result = map(addition, numbers)\n",
+    "    print(list(result))\n",
+    "\t\n",
+    "\toutput: [2, 4, 6, 8]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44b461a0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "Written by Suliah Apatira, 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 (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
+}