04. Data Aggregates Part 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HyperLearning AI - Introduction to Python\n",
    "An introductory course to the Python 3 programming language, with a curriculum aligned to the Certified Associate in Python Programming (PCAP) examination syllabus (PCAP-31-02).<br/>\n",
    "https://knowledgebase.hyperlearning.ai/courses/introduction-to-python\n",
    "\n",
    "\n",
    "## 04. Data Aggregates Part 1\n",
    "https://knowledgebase.hyperlearning.ai/courses/introduction-to-python/modules/4/data-aggregates-part-1\n",
    "\n",
    "In this module we will cover advanced operations with strings and lists, namely:\n",
    "\n",
    "* **Advanced Strings** - immutability, encodings, escape sequences, string comparisons, multi-line strings, slicing, copying, cloning, and other common string methods and functions\n",
    "* **Advanced Lists** - indexing, slicing, iterating, list comprehension, copying, cloning, and other common list methods and functions\n",
    "* **Matrices and Cubes** - lists within lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Advanced Strings\n",
    "#### 1.1. Character Encodings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name for Hospital in French is: hôpital\n",
      "The name for Hospital in Japanese is: 病院\n",
      "The name for Hospital in Arabic is: مستشفى\n"
     ]
    }
   ],
   "source": [
    "# Include a Unicode character in a Python 3 string literal\n",
    "hospital_in_french = 'hôpital'\n",
    "hospital_in_japanese = '病院'\n",
    "hospital_in_arabic = 'مستشفى'\n",
    "print(f'The name for Hospital in French is: {hospital_in_french}')\n",
    "print(f'The name for Hospital in Japanese is: {hospital_in_japanese}')\n",
    "print(f'The name for Hospital in Arabic is: {hospital_in_arabic}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The population of Japan is: 126500000\n"
     ]
    }
   ],
   "source": [
    "# Include a Unicode character in a Python 3 identifier\n",
    "日本の人口 = 126_500_000\n",
    "print(f'The population of Japan is: {日本の人口}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'The name of the hospital is Charit\\\\xe9 - Universit\\\\xe4tsmedizin Berlin'\n",
      "b'The name of the hospital is Charit - Universittsmedizin Berlin'\n",
      "b'The name of the hospital is Charit\\\\N{LATIN SMALL LETTER E WITH ACUTE} - Universit\\\\N{LATIN SMALL LETTER A WITH DIAERESIS}tsmedizin Berlin'\n",
      "b'The name of the hospital is Charit? - Universit?tsmedizin Berlin'\n",
      "b'The name of the hospital is Charit&#233; - Universit&#228;tsmedizin Berlin'\n"
     ]
    }
   ],
   "source": [
    "# Usage of the encode() string method\n",
    "directions = 'The name of the hospital is Charité - Universitätsmedizin Berlin'\n",
    "print(directions.encode(encoding=\"ascii\", errors=\"backslashreplace\"))\n",
    "print(directions.encode(encoding=\"ascii\", errors=\"ignore\"))\n",
    "print(directions.encode(encoding=\"ascii\", errors=\"namereplace\"))\n",
    "print(directions.encode(encoding=\"ascii\", errors=\"replace\"))\n",
    "print(directions.encode(encoding=\"ascii\", errors=\"xmlcharrefreplace\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Quddus', 'G\\xf6\\xdfmann', 'Jos\\xe9\\u611b']\n"
     ]
    }
   ],
   "source": [
    "# Usage of the ascii() function\n",
    "names = ['Quddus', 'Gößmann', 'José']\n",
    "print(ascii(names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Unicode code point value for 愛 is 24859\n"
     ]
    }
   ],
   "source": [
    "# Usage of the ord() function\n",
    "dragon = \"竜\"\n",
    "print(f'The Unicode code point value for {dragon} is {ord(dragon)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2. Escape Sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escaping a ' single quote character\n",
      "Escaping a \" double quote character\n",
      "Escaping a \\ backslash character\n",
      "Escaping a newline character\n",
      "Escaping an \u0007 ASCII bell character\n",
      "Escaping an \b ASCII backspace character\n",
      "Escaping an \f",
      " ASCII formfeed character\n",
      "Escaping an \n",
      " ASCII linefeed character\n",
      "Escaping an \r",
      " ASCII carriage return character\n",
      "Escaping an \t ASCII horizontal tab character\n",
      "Escaping an \u000b",
      " ASCII vertical tab character\n",
      "Escaping the ö German umlaut o character\n",
      "Escaping the 🐁 Unicode mouse character\n",
      "Escaping the ✈ Unicode airplane character\n"
     ]
    }
   ],
   "source": [
    "# Usage of escape characters\n",
    "print('Escaping a \\' single quote character')\n",
    "print(\"Escaping a \\\" double quote character\")\n",
    "print('Escaping a \\\\ backslash character')\n",
    "print('Escaping a \\\n",
    "newline character')\n",
    "print('Escaping an \\a ASCII bell character')\n",
    "print('Escaping an \\b ASCII backspace character')\n",
    "print('Escaping an \\f ASCII formfeed character')\n",
    "print('Escaping an \\n ASCII linefeed character')\n",
    "print('Escaping an \\r ASCII carriage return character')\n",
    "print('Escaping an \\t ASCII horizontal tab character')\n",
    "print('Escaping an \\v ASCII vertical tab character')\n",
    "\n",
    "# Usage of escape sequences\n",
    "print('Escaping the \\xf6 German umlaut o character')\n",
    "print('Escaping the \\N{MOUSE} Unicode mouse character')\n",
    "print('Escaping the \\u2708 Unicode airplane character')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3. Immutable Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-43-e6985690a63c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mtest_string\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Hello World'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_string\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mtest_string\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Q\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Try to change a character in a string\n",
    "test_string = 'Hello World'\n",
    "print(test_string[6])\n",
    "test_string[6] = \"Q\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id(my_first_string) = 140669325644208\n",
      "id(my_second_string) = 140669325644208\n",
      "a = 140669646981680\n",
      "b = 140669647076336\n",
      "r = 140669647801520\n",
      "a = 140669646981680\n",
      "c = 140669647497712\n",
      "a = 140669646981680\n",
      "d = 140669647497456\n",
      "a = 140669646981680\n",
      "b = 140669647076336\n",
      "r = 140669647801520\n",
      "a = 140669646981680\n"
     ]
    }
   ],
   "source": [
    "# Apply the id() function to strings\n",
    "my_first_string = 'abracadabra'\n",
    "my_second_string = 'abracadabra'\n",
    "print(f'id(my_first_string) = {id(my_first_string)}')\n",
    "print(f'id(my_second_string) = {id(my_second_string)}')\n",
    "\n",
    "# Apply the id() function to each character in a string\n",
    "for idx in range(0, len(my_first_string)):\n",
    "    print(f'{my_first_string[idx]} = {id(my_first_string[idx])}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a Data Scientist\n",
      "I am a Software Engineer\n"
     ]
    }
   ],
   "source": [
    "# Strings are immutable, but variables can be changed to point to different things\n",
    "my_string = 'I am a Data Scientist'\n",
    "print(my_string)\n",
    "my_string = 'I am a Software Engineer'\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.4. Multi-Line Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line 1\tEOL \n",
      "Line 2\t\tEOL\n",
      "Line 3    EOL\n"
     ]
    }
   ],
   "source": [
    "my_multiline_string = '''Line 1\\tEOL \n",
    "Line 2\\t\\tEOL\n",
    "Line 3    EOL'''\n",
    "print(my_multiline_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5. String Comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ö has length 1\n",
      "ö has length 2\n"
     ]
    }
   ],
   "source": [
    "# Represent the German umlaut using two different code point sequences\n",
    "umlaut_sequence_1 = '\\u00F6'\n",
    "umlaut_sequence_2 = '\\u006F\\u0308'\n",
    "print(f'{umlaut_sequence_1} has length {len(umlaut_sequence_1)}')\n",
    "print(f'{umlaut_sequence_2} has length {len(umlaut_sequence_2)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Compare strings that contain different code point sequences\n",
    "import unicodedata\n",
    "print(umlaut_sequence_1 == umlaut_sequence_2)\n",
    "print(unicodedata.normalize('NFD', umlaut_sequence_1) == unicodedata.normalize('NFD', umlaut_sequence_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.6. Advanced String Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arcdba\n",
      "abdcra\n",
      "cdb\n",
      "cdba\n"
     ]
    }
   ],
   "source": [
    "# Create a string\n",
    "my_string = 'abracadabra'\n",
    "\n",
    "# Extract characters of a string that have even indexes using the stride size argument\n",
    "print(my_string[::2])\n",
    "\n",
    "# Use a negative stride size argument to extract in reverse order\n",
    "print(my_string[::-2])\n",
    "\n",
    "# Extract a defined subset of characters with a stride size of 2 within that subset\n",
    "print(my_string[4:10:2])\n",
    "\n",
    "# Extract characters with even indexes starting from the 5th character\n",
    "print(my_string[4::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.7. Copying and Cloning Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id(my_first_string) = 140605555739120\n",
      "id(my_second_string) = 140605555739120\n"
     ]
    }
   ],
   "source": [
    "# Create two variables to point to the same string\n",
    "my_first_string = 'abracadabra'\n",
    "my_second_string = 'abracadabra'\n",
    "print(f'id(my_first_string) = {id(my_first_string)}')\n",
    "print(f'id(my_second_string) = {id(my_second_string)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_third_string = 'cadabra'\n",
      "id(my_third_string) = 140605555271216\n"
     ]
    }
   ],
   "source": [
    "# Create a new variable bound to a subset of a string using slice notation\n",
    "my_third_string = my_first_string[4:]\n",
    "print(f'my_third_string = \\'{my_third_string}\\'')\n",
    "print(f'id(my_third_string) = {id(my_third_string)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.8. Common String Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "Capitalize me\n"
     ]
    }
   ],
   "source": [
    "# isupper()\n",
    "print('MY NAME IS JILLUR'.isupper())\n",
    "\n",
    "# islower()\n",
    "print('my name is jillur Q'.islower())\n",
    "\n",
    "# isalpha()\n",
    "print('learning python'.isalpha())\n",
    "\n",
    "# isalnum()\n",
    "print('learning python 3'.isalnum())\n",
    "\n",
    "# isdecimal()\n",
    "print('01092020'.isdecimal())\n",
    "\n",
    "# isspace()\n",
    "print(' \\t\\n\\t\\v  '.isspace())\n",
    "\n",
    "# istitle()\n",
    "print('Jillur Quddus'.istitle())\n",
    "\n",
    "# capitalize()\n",
    "print('capitalize me'.capitalize())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.9. Common String Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "☺\n",
      "24859\n"
     ]
    }
   ],
   "source": [
    "# len()\n",
    "print(len('abracadabra'))\n",
    "\n",
    "# chr()\n",
    "print(chr(9786))\n",
    "\n",
    "# ord()\n",
    "print(ord('愛'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Advanced Lists\n",
    "#### 2.1. Index and Negative Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "1\n",
      "16\n",
      "100\n",
      "49\n"
     ]
    }
   ],
   "source": [
    "# Create a list containing the first ten square numbers\n",
    "squares = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
    "print(squares)\n",
    "\n",
    "# Access elements in a list by their index numbers\n",
    "print(squares[0])\n",
    "print(squares[3])\n",
    "print(squares[-1])\n",
    "print(squares[-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2. Advanced List Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81]\n",
      "[100, 64, 36, 16, 4]\n",
      "[25, 49]\n",
      "[25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "# Extract elements from a list that have even indexes using the stride size argument\n",
    "print(squares[::2])\n",
    "\n",
    "# Use a negative stride size argument to extract elements in reverse order\n",
    "print(squares[::-2])\n",
    "\n",
    "# Extract a defined subset of elements with a stride size of 2 within that subset\n",
    "print(squares[4:8:2])\n",
    "\n",
    "# Extract elements with even indexes starting from the 5th element\n",
    "print(squares[4::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3. Advanced List Slice Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My list of numbers (first 10 triangle numbers): [1, 3, 6, 10, 15, 21, 28, 36, 45, 55]\n",
      "My list of numbers (substitutions): [1, 4, 9, 10, 15, 21, 28, 36, 45, 55]\n",
      "My list of numbers (n-th replacements): [1, 4, 9, 16, 15, 21, 49, 36, 45, 100]\n",
      "My list of numbers (first 8 square numbers): [1, 4, 9, 16, 25, 36, 49, 64]\n",
      "My list of numbers (every other square number): [1, 9, 25, 49]\n"
     ]
    }
   ],
   "source": [
    "# Define a list of numbers\n",
    "my_numbers = [1, 3, 6, 10, 15, 21, 28, 36, 45, 55]\n",
    "print(f'My list of numbers (first 10 triangle numbers): {my_numbers}')\n",
    "\n",
    "# Substitute a subset of the list with new elements\n",
    "my_numbers[1:3] = [4, 9]\n",
    "print(f'My list of numbers (substitutions): {my_numbers}')\n",
    "\n",
    "# Replace every Nth element with a new value, where N = 3\n",
    "my_numbers[::3] = [1, 16, 49, 100]\n",
    "print(f'My list of numbers (n-th replacements): {my_numbers}')\n",
    "\n",
    "# Replace and resize a subset of the list\n",
    "my_numbers[4:] = [25, 36, 49, 64]\n",
    "print(f'My list of numbers (first 8 square numbers): {my_numbers}')\n",
    "\n",
    "# Delete every Nth element starting from the 2nd element and where N = 2\n",
    "del my_numbers[1::2]\n",
    "print(f'My list of numbers (every other square number): {my_numbers}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4. Shallow and Deep List Copies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of phrases: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n",
      "Shallow copy of my phrases: [['a', 'b', 'c'], ['d', 'e', 'f'], ['j', 'k', 'l']]\n",
      "Another shallow copy of my phrases: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i'], ['j', 'k', 'l']]\n",
      "\n",
      "Updated original list of phrases: [['ALPHA', 'BETA', 'GAMMA'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n",
      "Shallow copy of my phrases: [['ALPHA', 'BETA', 'GAMMA'], ['d', 'e', 'f'], ['j', 'k', 'l']]\n",
      "Another shallow copy of my phrases: [['ALPHA', 'BETA', 'GAMMA'], ['d', 'e', 'f'], ['g', 'h', 'i'], ['j', 'k', 'l']]\n"
     ]
    }
   ],
   "source": [
    "# Define a list of phrases\n",
    "my_phrases = [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n",
    "print(f'Original list of phrases: {my_phrases}')\n",
    "    \n",
    "# Create a shallow copy of the original list using slice notation, plus append a new element\n",
    "my_shallow_phrases = my_phrases[:2] + [['j', 'k', 'l']]\n",
    "print(f'Shallow copy of my phrases: {my_shallow_phrases}')\n",
    "    \n",
    "# Alternatively you may use the list() function to create a shallow copy\n",
    "my_other_shallow_phrases = list(my_phrases) + [['j', 'k', 'l']]\n",
    "print(f'Another shallow copy of my phrases: {my_other_shallow_phrases}')\n",
    "\n",
    "# Make a change to the original list of phrases only\n",
    "my_phrases[0][0] = 'ALPHA'\n",
    "my_phrases[0][1] = 'BETA'\n",
    "my_phrases[0][2] = 'GAMMA'\n",
    "print(f'\\nUpdated original list of phrases: {my_phrases}')\n",
    "\n",
    "# Examine the shallow copies of the original list\n",
    "print(f'Shallow copy of my phrases: {my_shallow_phrases}')\n",
    "print(f'Another shallow copy of my phrases: {my_other_shallow_phrases}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of phrases: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n",
      "Deep copy of my phrases: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n",
      "\n",
      "Updated original list of phrases: [['ALPHA', 'BETA', 'GAMMA'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n",
      "Deep copy of my phrases: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n"
     ]
    }
   ],
   "source": [
    "# Create a deep copy of the original list\n",
    "import copy\n",
    "\n",
    "my_phrases = [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n",
    "my_deep_phrases = copy.deepcopy(my_phrases)\n",
    "print(f'Original list of phrases: {my_phrases}')\n",
    "print(f'Deep copy of my phrases: {my_deep_phrases}')\n",
    "\n",
    "# Make a change to the original list of phrases only\n",
    "my_phrases[0][0] = 'ALPHA'\n",
    "my_phrases[0][1] = 'BETA'\n",
    "my_phrases[0][2] = 'GAMMA'\n",
    "print(f'\\nUpdated original list of phrases: {my_phrases}')\n",
    "\n",
    "# Examine the deep copy of the original list\n",
    "print(f'Deep copy of my phrases: {my_deep_phrases}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.5. Iterating Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diatomic Sequence - Element #1: 0\n",
      "Diatomic Sequence - Element #2: 1\n",
      "Diatomic Sequence - Element #3: 1\n",
      "Diatomic Sequence - Element #4: 2\n",
      "Diatomic Sequence - Element #5: 1\n",
      "Diatomic Sequence - Element #6: 3\n",
      "Diatomic Sequence - Element #7: 2\n",
      "Diatomic Sequence - Element #8: 3\n",
      "Diatomic Sequence - Element #9: 1\n",
      "Diatomic Sequence - Element #10: 4\n",
      "Diatomic Sequence - Element #11: 3\n",
      "Diatomic Sequence - Element #12: 5\n",
      "Diatomic Sequence - Element #13: 2\n",
      "Diatomic Sequence - Element #14: 5\n",
      "Diatomic Sequence - Element #15: 3\n",
      "Diatomic Sequence - Element #16: 4\n"
     ]
    }
   ],
   "source": [
    "# Create a list\n",
    "my_diatomic_list = [0, 1, 1, 2, 1, 3, 2, 3, 1, 4, 3, 5, 2, 5, 3, 4]\n",
    "\n",
    "# Iterate the list using a while loop\n",
    "i = 0\n",
    "while i < len(my_diatomic_list):\n",
    "    print(f'Diatomic Sequence - Element #{i + 1}: {my_diatomic_list[i]}')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diatomic Sequence - Element #1: 0\n",
      "Diatomic Sequence - Element #2: 1\n",
      "Diatomic Sequence - Element #3: 1\n",
      "Diatomic Sequence - Element #4: 2\n",
      "Diatomic Sequence - Element #5: 1\n",
      "Diatomic Sequence - Element #6: 3\n",
      "Diatomic Sequence - Element #7: 2\n",
      "Diatomic Sequence - Element #8: 3\n",
      "Diatomic Sequence - Element #9: 1\n",
      "Diatomic Sequence - Element #10: 4\n",
      "Diatomic Sequence - Element #11: 3\n",
      "Diatomic Sequence - Element #12: 5\n",
      "Diatomic Sequence - Element #13: 2\n",
      "Diatomic Sequence - Element #14: 5\n",
      "Diatomic Sequence - Element #15: 3\n",
      "Diatomic Sequence - Element #16: 4\n"
     ]
    }
   ],
   "source": [
    "# Iterate the list using a for loop with the range function\n",
    "for x in range(len(my_diatomic_list)):\n",
    "    print(f'Diatomic Sequence - Element #{x + 1}: {my_diatomic_list[x]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "1\n",
      "3\n",
      "2\n",
      "3\n",
      "1\n",
      "4\n",
      "3\n",
      "5\n",
      "2\n",
      "5\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Iterate the list using a for loop with the in operator\n",
    "for elem in my_diatomic_list:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diatomic Sequence - Element #1: 0\n",
      "Diatomic Sequence - Element #2: 1\n",
      "Diatomic Sequence - Element #3: 1\n",
      "Diatomic Sequence - Element #4: 2\n",
      "Diatomic Sequence - Element #5: 1\n",
      "Diatomic Sequence - Element #6: 3\n",
      "Diatomic Sequence - Element #7: 2\n",
      "Diatomic Sequence - Element #8: 3\n",
      "Diatomic Sequence - Element #9: 1\n",
      "Diatomic Sequence - Element #10: 4\n",
      "Diatomic Sequence - Element #11: 3\n",
      "Diatomic Sequence - Element #12: 5\n",
      "Diatomic Sequence - Element #13: 2\n",
      "Diatomic Sequence - Element #14: 5\n",
      "Diatomic Sequence - Element #15: 3\n",
      "Diatomic Sequence - Element #16: 4\n"
     ]
    }
   ],
   "source": [
    "# Iterate the list using a for loop with the in operator and enumerate function\n",
    "for idx, elem in enumerate(my_diatomic_list):\n",
    "    print(f'Diatomic Sequence - Element #{idx + 1}: {elem}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.6. List Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16 exists in our list of square numbers\n",
      "169 does not exist in our list of square numbers\n"
     ]
    }
   ],
   "source": [
    "# Test whether an element exists in a list\n",
    "squares = [1, 4, 9, 16, 25]\n",
    "x = 16\n",
    "if x in squares:\n",
    "    print(f\"{x} exists in our list of square numbers\")\n",
    "else:\n",
    "    print(f\"{x} does not exist in our list of square numbers\")\n",
    "    \n",
    "# Test whether an element is NOT in a list\n",
    "y = 169\n",
    "if y not in squares:\n",
    "    print(f\"{y} does not exist in our list of square numbers\")\n",
    "else:\n",
    "    print(f\"{y} exists in our list of square numbers\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.7. List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of square numbers using list comprehension\n",
    "squares = [num * num for num in range(1, 9)]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'i', 'b', 'l', 'i', 'o', 'p', 'h', 'o', 'b', 'i', 'a']\n"
     ]
    }
   ],
   "source": [
    "# Create a list formed of characters from a string\n",
    "letters_in_abibliophobia = [character for character in 'abibliophobia']\n",
    "print(letters_in_abibliophobia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of all the prime numbers between 1 and 100\n",
    "def isPrime(num):\n",
    "    if num <= 1 or num % 1 > 0:\n",
    "        return False\n",
    "    for i in range(2, num//2):\n",
    "        if num % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "prime_numbers = [i for i in range(1, 101) if isPrime(i)]\n",
    "print(prime_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 0, 4, 0, 6, 0, 8, 0, 10, 0, 12, 0, 14, 0, 16, 0, 18, 0, 20, 0, 22, 0, 24, 0, 26, 0, 28, 0, 30, 0, 32, 0, 34, 0, 36, 0, 38, 0, 40, 0, 42, 0, 44, 0, 46, 0, 48, 0, 50, 0, 52, 0, 54, 0, 56, 0, 58, 0, 60, 0, 62, 0, 64, 0, 66, 0, 68, 0, 70, 0, 72, 0, 74, 0, 76, 0, 78, 0, 80, 0, 82, 0, 84, 0, 86, 0, 88, 0, 90, 0, 92, 0, 94, 0, 96, 0, 98, 0, 100]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of all the even numbers between 1 and 100, and replace the odd numbers with 0\n",
    "even_numbers_zeroed_odd = [i if i % 2 == 0 else 0 for i in range(1, 101)]\n",
    "print(even_numbers_zeroed_odd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.8. Common List Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of square numbers\n",
    "squares = [1, 4, 9, 16]\n",
    "more_squares = [25, 36, 49, 64, 81, 100]\n",
    "\n",
    "# list.append(element)\n",
    "squares.append(25)\n",
    "print(squares)\n",
    "\n",
    "# list.extend(newlist)\n",
    "del more_squares[0]\n",
    "squares.extend(more_squares)\n",
    "print(squares)\n",
    "\n",
    "# list.insert(index, element)\n",
    "squares.insert(0, 0)\n",
    "print(squares)\n",
    "\n",
    "# list.remove(element)\n",
    "squares.remove(0)\n",
    "print(squares)\n",
    "\n",
    "# list.pop([index])\n",
    "squares.pop()\n",
    "print(squares)\n",
    "\n",
    "# list.clear()\n",
    "squares.clear()\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "0\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "[100, 81, 64, 49, 36, 25, 16, 9, 4, 1]\n",
      "[100, 81, 64, 49, 36, 25, 16, 9, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "# Populate the list of square numbers again\n",
    "squares.extend([1, 4, 9, 16, 25, 36, 49, 64, 81, 100])\n",
    "\n",
    "# list.index(element[, start[, end]])\n",
    "print(squares.index(64))\n",
    "\n",
    "# list.count(element)\n",
    "print(squares.count(169))\n",
    "\n",
    "# list.sort()\n",
    "squares.sort()\n",
    "print(squares)\n",
    "\n",
    "# list.reverse()\n",
    "squares.reverse()\n",
    "print(squares)\n",
    "\n",
    "# list.copy()\n",
    "squares_copy = squares.copy()\n",
    "print(squares_copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.9. Common List Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "[4, 7, 10, 13, 24, 34, 101]\n",
      "['e', 'f', 'j', 'x', 'z']\n",
      "101\n",
      "z\n",
      "4\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "# Create a list of numbers\n",
    "my_numbers = [34, 13, 101, 4, 10, 24, 7]\n",
    "\n",
    "# Create a list of letters\n",
    "my_letters = ['j', 'z', 'e', 'f', 'x']\n",
    "\n",
    "# len()\n",
    "print(len(my_numbers))\n",
    "\n",
    "# sorted()\n",
    "print(sorted(my_numbers))\n",
    "print(sorted(my_letters))\n",
    "\n",
    "# max()\n",
    "print(max(my_numbers))\n",
    "print(max(my_letters))\n",
    "\n",
    "# min()\n",
    "print(min(my_numbers))\n",
    "print(min(my_letters))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Lists in Lists\n",
    "#### 3.1. Multi-Dimensional Arrays\n",
    "#### 3.1.1. Two-Dimensional Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 \n",
      "4 5 6 \n",
      "7 8 9 \n"
     ]
    }
   ],
   "source": [
    "# Create a two-dimensional array\n",
    "my_2d_array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "for row in my_2d_array:\n",
    "    for elem in row:\n",
    "        print(elem, end=' ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 \n",
      "0 0 0 \n",
      "0 0 0 \n"
     ]
    }
   ],
   "source": [
    "# Create a two-dimensional array with list comprehension\n",
    "number_cols = 3\n",
    "number_rows = 3\n",
    "my_2d_array = [[0 for i in range(number_cols)] for j in range(number_rows)]\n",
    "for row in my_2d_array:\n",
    "    for elem in row:\n",
    "        print(elem, end=' ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Access elements using square brackets and indices\n",
    "my_2d_array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "print(my_2d_array[0][0])\n",
    "print(my_2d_array[1][1])\n",
    "print(my_2d_array[2][2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 0 0 \n",
      "4 0 6 0 0 \n",
      "0 0 9 9 9 \n",
      "7 4 7 0 0 \n"
     ]
    }
   ],
   "source": [
    "# Create a two-dimensional array\n",
    "my_2d_array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    "# Update a specific element in our two-dimensional array\n",
    "my_2d_array[1][1] = 0\n",
    "\n",
    "# Insert a new row in our two-dimensional array at a given row number using the insert method\n",
    "my_2d_array.insert(2, [9, 9, 9])\n",
    "\n",
    "# Append a new row to our two-dimensional array using the append method\n",
    "my_2d_array.append([7, 4, 7])\n",
    "\n",
    "# Append elements to an existing row in our two-dimensional array at a given row number using the extend method\n",
    "my_2d_array[0].extend([0, 0])\n",
    "my_2d_array[1].extend([0, 0])\n",
    "my_2d_array[2].extend([0, 0])\n",
    "my_2d_array[3].extend([0, 0])\n",
    "my_2d_array[4].extend([0, 0])\n",
    "\n",
    "# Reverse the order of the elements in a given row in our two-dimensional array using the reverse method\n",
    "my_2d_array[2].reverse()\n",
    "\n",
    "# Delete a row at a given row number from our two-dimensional array\n",
    "del my_2d_array[3]\n",
    "\n",
    "# Display out final two-dimensional array\n",
    "for row in my_2d_array:\n",
    "    for elem in row:\n",
    "        print(elem, end=' ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 0 0 \n",
      "4 0 6 0 0 \n",
      "0 0 9 9 9 \n",
      "7 8 9 0 0 \n",
      "7 4 7 0 0 \n"
     ]
    }
   ],
   "source": [
    "for row in my_2d_array:\n",
    "    for elem in row:\n",
    "        print(elem, end=' ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1.2. Three-Dimensional Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0, 1, 2], [1, 2, 3], [2, 3, 4]],\n",
      " [[1, 2, 3], [2, 3, 4], [3, 4, 5]],\n",
      " [[2, 3, 4], [3, 4, 5], [4, 5, 6]]]\n",
      "[3, 4, 5]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "\n",
    "# Create a three-dimensional array of size 3 x 3 x 3\n",
    "my_3d_array = [[[x + y + z for x in range(3)] for y in range(3)] for z in range(3)]\n",
    "pprint.pprint(my_3d_array)\n",
    "\n",
    "# Access a list element in our three-dimensional array\n",
    "print(my_3d_array[1][2])\n",
    "\n",
    "# Access a specific element in our three-dimensional array \n",
    "print(my_3d_array[2][0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Comparing Sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Compare two given strings using comparison operators\n",
    "print(\"Hello\" > \"Hello\")\n",
    "print(\"Hello\" < \"Hello\")\n",
    "print(\"abracadabra\" > \"Hello\")\n",
    "print(\"abracadabra\" > \"Hello\")\n",
    "print('a' < 'b' < 'c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Compare two given lists using comparison operators\n",
    "print([1, 2, 3] > [1, 2, 3])\n",
    "print([1, 2, 3] < [1, 2, 3])\n",
    "print([1, 2, 3] > [1, 2, 4])\n",
    "print([1, 2, 3] < [1, 2, 4])"
   ]
  }
 ],
 "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": 4
}