Notebooks/Example-004-Python-Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists in Python\n",
    "\n",
    "<p>\n",
    "In most languages a collection of homogeneous (all of the same type)\n",
    "entities is called an array. The size of the array is fixed at the\n",
    "time of creation, however, the contents of the  array can be changed\n",
    "during the course of the execution of the program. Higher dimensional\n",
    "arrays are also possible, where each element of an array is an array.\n",
    "</p>\n",
    "\n",
    "<p>\n",
    "The analogue of an array in Python is a <i>list</i>. Even though a \n",
    "list defines a collection of things it has different properties from\n",
    "an array. A list could be a collection of heterogeneous (different\n",
    "types) items. The size of a list is dynamic. It is not specified at\n",
    "the time of creation and can grow or shrink as needed. A list could\n",
    "have duplicate items. The order of the items in a list is important\n",
    "and not their uniqueness. Python also provides built-in functions to \n",
    "manipulate a list and its contents. A higher dimensional list has \n",
    "elements that are themselves lists. Given the flexibility and the \n",
    "associated functions, a Python list is a more powerful data structure \n",
    "than an array.\n",
    "</p>\n",
    "\n",
    "<h3> List Creation </h3>\n",
    "<p>\n",
    "There are several ways in which to create a list. You can enumerate\n",
    "all the elements of a list or create an empty list and then append\n",
    "or insert items into the list. When you append an item to a list, that\n",
    "item is added to the end of the list. To insert an item into a list\n",
    "you must specify its position and then all the elements to the right\n",
    "or below it are shifted to make space for it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Enumerate the items\n",
    "a = [1, 2, 3]\n",
    "a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[1]\n",
      "[1, 2]\n",
      "[1, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "# Create an empty list and append or insert\n",
    "a = []\n",
    "print(a)\n",
    "\n",
    "a.append(1)            #  a = [1]\n",
    "print(a)\n",
    "\n",
    "a.append(2)            #  a = [1, 2]\n",
    "print(a)\n",
    "\n",
    "a.insert(1, 3)         #  a = [1, 3, 2]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a two dimensional list\n",
    "b = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]\n",
    "\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the positions of items in a list start at an index value of 0.\n",
    "You can also create a list by concatenating two or more lists together.\n",
    "You can initialize a list with a predefined value.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5]\n",
      "[0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "b = [4, 5]\n",
    "c = a + b               #  c = [1, 2, 4, 5]\n",
    "\n",
    "print(c)\n",
    "\n",
    "d = [0] * 5             #  d = [0, 0, 0, 0, 0]\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5]\n",
      "[5 7]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2,)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np \n",
    "\n",
    "a1 = np.array(a)\n",
    "b1 = np.array(b)\n",
    "\n",
    "print(a + b)\n",
    "\n",
    "print(a1 + b1)\n",
    "\n",
    "a1.shape\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic List Manipulations\n",
    "To obtain the length of a list you can use the <i>len()</i> function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "length = len (a)         # length = 3\n",
    "length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing\n",
    "The items in a list are indexed starting at 0 and ending at index\n",
    "<i>length - 1</i>. You can also use negative indices to access elements\n",
    "in a list. For example a[-1] returns the last item on the list and\n",
    "a[-length] returns the first. Unlike a string, a list is mutable, i.e.\n",
    "its contents can be changed like so:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "\n",
    "a[1] = 4                 # a = [1, 4, 3]\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access or change an element in a 2-dimensional list specify the row\n",
    "first and then the column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "6\n",
      "[[1, 2, 3], [4, 5, 6], [7, 12, 9]]\n"
     ]
    }
   ],
   "source": [
    "b = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]\n",
    "print(b)\n",
    "\n",
    "d = b[1][2]            #  d = 6\n",
    "\n",
    "print(d)\n",
    "\n",
    "b[2][1] = b[1][2]*2\n",
    "\n",
    "print(b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the positions of items in a list start at an index value of 0.\n",
    "You can also create a list by concatenating two or more lists together.\n",
    "You can initialize a list with a predefined value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "b = [4, 5]\n",
    "c = a + b               #  c = [1, 2, 4, 5]\n",
    "\n",
    "print(c)\n",
    "\n",
    "d = [0] * 5             #  d = [0, 0, 0, 0, 0]\n",
    "\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Traversal\n",
    "\n",
    "<p>\n",
    "One of the most important operations that you can do with a list is to\n",
    "traverse it, i.e. visit each and every element in the list in order.\n",
    "There are several ways in which to do so:\n",
    "<pre>\n",
    "        \n",
    "</pre>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 2, 6, 4, 7]\n",
      "9 2 6 4 7 "
     ]
    }
   ],
   "source": [
    "a = [9, 2, 6, 4, 7]\n",
    "\n",
    "print(a)\n",
    "\n",
    "for item in a:\n",
    "    print (item, end = \" \") # 9 2 6 4 7\n",
    "\n",
    "\n",
    "# Doubles each item in the list\n",
    "length = len (a)\n",
    "\n",
    "for i in range(length):\n",
    "    a[i] = a[i] * 2  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<a href = \"https://docs.python.org/3/tutorial/datastructures.html\">\n",
    "Other List Functions </a> \n",
    "\n",
    "\n",
    "<table border = \"1\" width = \"75%\">\n",
    "<tr>\n",
    "<th> Function </th><th> Meaning </th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td> list.sort() </td>\n",
    "<td> Sorts a list in ascending order </td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td> list.reverse() </td>\n",
    "<td> Reverses the elements in a list </td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td> <i>value</i> in list </td>\n",
    "<td> Returns True if the <i>value</i> is in the list and False otherwise</td>\n",
    "</tr>\n",
    "<tr> \n",
    "<td> list.index(x) </td>\n",
    "<td> Returns the index of the first occurence of x. Use with the above\n",
    "function to check if <i>x</i> is in the list before determining its position.\n",
    "</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td> list.count(x) </td>\n",
    "<td> Returns the number of occurences of x in the list </td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td> list.remove(x) </td>\n",
    "<td> Deletes the first occurence of x in list </td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td> list.pop(i) </td>\n",
    "<td> Deletes the ith element in the list and returns its value </td>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 7, 9]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [9, 2, 6, 4, 7]\n",
    "a.sort()\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 4, 6, 2, 9]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [9, 2, 6, 4, 7]\n",
    "a.reverse()\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "2\n",
      "6\n",
      "4\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for value in  [9, 2, 6, 4, 7]:\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#index\n",
    "a = [9, 2, 6, 4, 7]\n",
    "\n",
    "a.index(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# count()\n",
    "a = [9, 2, 6, 6, 4, 7]\n",
    "\n",
    "a.count(6)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 6, 4, 2, 7]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# remove\n",
    "a = [9, 2, 6, 4,2, 7]\n",
    "a.remove(2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[9, 2, 4, 7]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pop\n",
    "a = [9, 2, 6, 4, 7]\n",
    "\n",
    "b = a.pop(2)\n",
    "print(b)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Comprehensions\n",
    "\n",
    "https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1000, 3, 1000]\n"
     ]
    }
   ],
   "source": [
    "# For example, we want to create a list p \n",
    "\n",
    "a  = [1, 2, 3, 4, 5, 6]\n",
    "b = [1, -2, 3, -6]\n",
    "\n",
    "p=[]\n",
    "\n",
    "for item in b:\n",
    "    if item in a:\n",
    "        p.append(item)\n",
    "    else:\n",
    "        p.append(1000)\n",
    "        \n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1000, 3, 1000]\n"
     ]
    }
   ],
   "source": [
    "# instead of the above we can write in python the following.\n",
    "p = [item if item in a else 1000 for item in b]\n",
    "\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}