1_python_numpy_basics/3_lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "stuffed-armor",
   "metadata": {},
   "source": [
    "# Lists in Python\n",
    "Python knows a number of compound data types, used to group together other values. The most versatile is the list, which can be written as a list of comma-separated values (items) between square brackets. Lists might contain items of different types, but usually the items all have the same type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "excess-bulgaria",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n",
      "[1, 'Python', 25.345, True]\n"
     ]
    }
   ],
   "source": [
    "squares = [1, 4, 9, 16, 25]\n",
    "print(squares)\n",
    "example = [1,'Python',25.345,True]\n",
    "print(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "biblical-frame",
   "metadata": {},
   "source": [
    "List items are ordered, changeable, and allow duplicate values ,meaning:\n",
    "* that the items have a defined order, and that order will not change.\n",
    "* we can change, add, and remove items in a list after it has been created and \n",
    "* since lists are indexed, lists can have items with the same value:\n",
    "\n",
    "**List items are indexed, the first item has index [0], the second item has index [1] etc.**\n",
    "\n",
    "Other way to index a list is **Negative Indexing**\n",
    "Negative indexing means start from the end\n",
    "\n",
    "`-1` refers to the last item, `-2` refers to the second last item etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "heavy-alarm",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First color:  red\n",
      "Third color:  green\n",
      "First color using negative indexing:  red\n",
      "Third color using negative indexing:  green\n"
     ]
    }
   ],
   "source": [
    "colors = ['red', 'blue', 'green']\n",
    "print('First color: ',colors[0])    # red\n",
    "print('Third color: ',colors[2])    # green\n",
    "print('First color using negative indexing: ',colors[-3])    # red\n",
    "print('Third color using negative indexing: ',colors[-1])    # green"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "durable-tomato",
   "metadata": {},
   "source": [
    "Assignment with an = on lists **does not make a copy**. Instead, assignment makes the two variables point to the one list in memory.\n",
    "\n",
    "Below we will cofirm this using the **id()** function provided by python.\n",
    "The **id()** function returns a unique id for the specified object.\n",
    "\n",
    "We can see that the **id()** returns same value for **colors** and **b**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "north-savings",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id of b     :  140663671669456\n",
      "id of colors:  140663671669456\n"
     ]
    }
   ],
   "source": [
    "b=colors\n",
    "print('id of b     : ',id(b))\n",
    "print('id of colors: ',id(colors))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "democratic-reliance",
   "metadata": {},
   "source": [
    "## Python List Slicing\n",
    "In Python, list slicing is a common practice and it is the most used technique for programmers to solve efficient problems. Consider a python list, In-order to access a range of elements in a list, you need to slice a list. One way to do this is to use the simple slicing operator i.e. colon(:)\n",
    "\n",
    "With this operator, one can specify where to start the slicing, where to end, and specify the step. List slicing returns a new list from the existing list.\n",
    "\n",
    "**Syntax:**  \n",
    "`Lst[ Initial : End : IndexJump ]`  \n",
    "If Lst is a list, then the above expression returns the portion of the list from index Initial to index End, at a step size IndexJump.\n",
    "\n",
    "**NOTE** : Value at Initial index i.e `Lst[Index]` is included and `Lst[End]` is exluded. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fitted-belly",
   "metadata": {},
   "source": [
    "### Slicing using Positive Indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "entertaining-hundred",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive Slicing example  [70, 20]\n",
      "Leaving out the start index  [50, 30, 90]\n",
      "Leaving out the Start index and Index Jump [50, 70, 30, 20]\n",
      "Leaving out the End index and Index Jump [30, 20, 90, 10, 50]\n"
     ]
    }
   ],
   "source": [
    "## Notice in the examples below that the End Index is excluded\n",
    "\n",
    "# Initialize list\n",
    "Lst = [50, 70, 30, 20, 90, 10, 50]\n",
    "\n",
    "# Positive slicing example\n",
    "print('Positive Slicing example ',Lst[1:5:2])\n",
    "\n",
    "# If start index not specified by default it starts from the beginning\n",
    "print('Leaving out the start index ',Lst[:5:2])\n",
    "\n",
    "#Not mandatory to specify the IndexJump...default value is 1\n",
    "print('Leaving out the Start index and Index Jump',Lst[:4])\n",
    "\n",
    "# If start index not specified by default it goes till the end\n",
    "print('Leaving out the End index and Index Jump',Lst[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sonic-nothing",
   "metadata": {},
   "source": [
    "### Slicing using Negative Indexes\n",
    "Index **-1** represents the **last element** and **-n** represents the **first element** of the list(considering n as the length of the list). Similarly -2 represents second last, -3 --> third last and so on. Lists can be manipulated using negative indexes also."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "sudden-rally",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Negative Slicing example  [30, 90]\n",
      "Leaving out the start index  [50, 30, 90]\n",
      "Leaving out the Start index and Index Jump [50, 70, 30, 20, 90]\n",
      "Leaving out the End index and Index Jump [20, 90, 10, 50]\n"
     ]
    }
   ],
   "source": [
    "# Initialize list\n",
    "Lst = [50, 70, 30, 20, 90, 10, 50]\n",
    "  \n",
    "# Negative Slicing example\n",
    "print('Negative Slicing example ',Lst[-5:-2:2])\n",
    "\n",
    "# If start index not specified by default it starts from the beginning\n",
    "print('Leaving out the start index ',Lst[:-2:2])\n",
    "\n",
    "#Not mandatory to specify the IndexJump...default value is 1\n",
    "print('Leaving out the Start index and Index Jump',Lst[:-2])\n",
    "\n",
    "# If start index not specified by default it goes till the end\n",
    "print('Leaving out the End index and Index Jump',Lst[-4:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cathedral-swaziland",
   "metadata": {},
   "source": [
    "## Changing Items of List\n",
    "You can change items in the list by refering the position at which you want to change by indexing and assigning the new value to it.  \n",
    "  \n",
    "Range of indexes can also be change in one go by refering to a slice and then assigning it a new list of values. The resultant length of the list changes depending upon the length of the slice refered and the length of list of values it is assigned.  \n",
    "  \n",
    "Refer the following examples and their output for a better understanding: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "measured-village",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Change the second item\n",
      "['apple', 'blackcurrent', 'cherry']\n",
      "Change the values \"banana\" and \"cherry\" with the values \"blackcurrant\" and \"watermelon\"\n",
      "['apple', 'blackcurrent', 'watermelon', 'orange', 'kiwi', 'mango']\n",
      "Change the second value by replacing it with two new values\n",
      "['apple', 'blackcurrent', 'watermelon', 'cherry']\n",
      "Change the second and third value by replacing it with one value\n",
      "['apple', 'watermelon']\n"
     ]
    }
   ],
   "source": [
    "print('Change the second item')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist[1] = \"blackcurrent\"\n",
    "print(thislist)\n",
    "\n",
    "print('Change the values \"banana\" and \"cherry\" with the values \"blackcurrant\" and \"watermelon\"')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"mango\"]\n",
    "thislist[1:3] = [\"blackcurrent\", \"watermelon\"]\n",
    "print(thislist)\n",
    "\n",
    "\"\"\"\"If you insert more items than you replace\n",
    "the new items will be inserted where you specified, and the remaining items will move accordingly\"\"\"\n",
    "\n",
    "print('Change the second value by replacing it with two new values')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist[1:2] = [\"blackcurrent\", \"watermelon\"]\n",
    "print(thislist)\n",
    "\n",
    "\"\"\"\"If you insert less items than you replace\n",
    "the new items will be inserted where you specified, and the remaining items will move accordingly\"\"\"\n",
    "\n",
    "print('Change the second and third value by replacing it with one value')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist[1:3] = [\"watermelon\"]\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accessible-maria",
   "metadata": {},
   "source": [
    "### len() \n",
    "returns the **number of items in the object passed** (here, list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "funky-omaha",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([10,20,30,40,50])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "laden-brighton",
   "metadata": {},
   "source": [
    "## Range\n",
    "The range(n) function yields the numbers 0, 1, ... n-1, and range(a, b) returns a, a+1, ... b-1 -- up to but not including the last number. The combination of the for-loop and the range() function allow you to build a traditional numeric for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "deluxe-effectiveness",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "## print the numbers from 0 through 99\n",
    "for i in range(5):\n",
    "   print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "polar-retirement",
   "metadata": {},
   "source": [
    "## List Methods\n",
    "### Here are some other common list methods.\n",
    "\n",
    "* list.append(elem) -- adds a single element to the end of the list. Common error: does not return the new list, just modifies the original.\n",
    "* list.insert(index, elem) -- inserts the element at the given index, shifting elements to the right.\n",
    "* list.extend(list2) adds the elements in list2 to the end of the list. Using + or += on a list is similar to using extend().\n",
    "* list.index(elem) -- searches for the given element from the start of the list and returns its index. Throws a ValueError if the element does not appear (use \"in\" to check without a ValueError).\n",
    "* list.remove(elem) -- searches for the first instance of the given element and removes it (throws ValueError if not present)\n",
    "* list.sort() -- sorts the list in place (does not return it). (The sorted() function shown later is preferred.)\n",
    "* list.reverse() -- reverses the list in place (does not return it)\n",
    "* list.pop(index) -- removes and returns the element at the given index. Returns the rightmost element if index is omitted (roughly the opposite of append()).  \n",
    "  \n",
    "Notice that these are *methods* on a list object, while len() is a function that takes the list (or string or whatever) as an argument.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "impressive-board",
   "metadata": {},
   "source": [
    "## Inserting Items\n",
    "To insert a new list item, without replacing any of the existing values, we can use the insert() method.\n",
    "\n",
    "The **insert()** method inserts an item at the specified index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "organized-charger",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'watermelon', 'cherry']\n"
     ]
    }
   ],
   "source": [
    "# Insert \"watermelon\" as the third item:\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist.insert(2, \"watermelon\")\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "palestinian-google",
   "metadata": {},
   "source": [
    "## Append Items\n",
    "To add an item to the end of the list, use the **append()** method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "least-expansion",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry', 'orange']\n"
     ]
    }
   ],
   "source": [
    "# Using the append() method to append an item:\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist.append(\"orange\")\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "entertaining-employer",
   "metadata": {},
   "source": [
    "## Extend List\n",
    "To append elements from another list to the current list, use the **extend()** method. The elements will be added to the end of the list.The extend() method does not have to append lists, you can **add any iterable object** (tuples, sets, dictionaries etc)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "featured-flight",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry', 'mango', 'pineapple', 'papaya']\n"
     ]
    }
   ],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "tropical = [\"mango\", \"pineapple\", \"papaya\"]\n",
    "thislist=thislist+tropical\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "introductory-anderson",
   "metadata": {},
   "source": [
    "## Remove Elements \n",
    "Following are some inbuilt python functions to delete items in a list. We can choose the method we want want to use from the below options depending upon our use case.\n",
    "* The **remove(`Value`)** method removes the specified item.\n",
    "* The **pop(`Index`)** method removes the specified index.\n",
    "* The **del(`Index`)** keyword also removes the specified index.\n",
    "* The **clear()** method empties the list. The list still remains, but it has no content. \n",
    "  \n",
    "**Examples of implementation of the above mentioned functions is shown below :** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "prostate-hardwood",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "remove() function :\n",
      "['apple', 'cherry']\n",
      "pop() function :\n",
      "['apple', 'cherry']\n",
      "pop() function :\n",
      "['apple', 'banana']\n",
      "del() function :\n",
      "['banana', 'cherry']\n",
      "del() function :\n",
      "clear() function :\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "#Remove \"banana\":\n",
    "print('remove() function :')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist.remove(\"banana\")\n",
    "print(thislist)\n",
    "\n",
    "#Remove the second item:\n",
    "print('pop() function :')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist.pop(1)\n",
    "print(thislist)\n",
    "\n",
    "#If you do not specify the index, the pop() method removes the last item.\n",
    "#Remove the last item:\n",
    "print('pop() function :')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist.pop()\n",
    "print(thislist)\n",
    "\n",
    "#Remove the first item:\n",
    "print('del() function :')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "del thislist[0]\n",
    "print(thislist)\n",
    "\n",
    "#Delete the entire list:\n",
    "print('del() function :')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "del thislist\n",
    "#If we uncomment the below line we will encounter an error because the list itself is deleted \n",
    "#print(thisList)\n",
    "\n",
    "#Clear the list content:\n",
    "print('clear() function :')\n",
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "thislist.clear()\n",
    "#Here we do not encounter error when we print as only the list items are deleted, not the list itself\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "better-tuition",
   "metadata": {},
   "source": [
    "## Looping through a List\n",
    "Some of the methos to loop through a list are :\n",
    "* You can loop through the list items by using a for loop\n",
    "* You can also loop through the list items by referring to their index numberby using the range() and len() functions to create a suitable iterable.\n",
    "* You can loop through the list items by using a while loop.  \n",
    "  Use the len() function to determine the length of the list, then start at 0 and loop your way through the list     items by refering to their indexes.  \n",
    "  Remember to increase the index by 1 after each iteration.\n",
    "* List Comprehension offers the shortest syntax for looping through lists\n",
    "\n",
    "Following is the implementation for the above methods to print all items in the list, one by one :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "dedicated-slovak",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st method :\n",
      "apple\n",
      "banana\n",
      "cherry\n",
      "\n",
      "2nd method :\n",
      "apple\n",
      "banana\n",
      "cherry\n",
      "\n",
      "3rd method :\n",
      "apple\n",
      "banana\n",
      "cherry\n",
      "\n",
      "4th method :\n",
      "apple\n",
      "banana\n",
      "cherry\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[None, None, None]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "thislist = [\"apple\", \"banana\", \"cherry\"]\n",
    "\n",
    "print('1st method :')\n",
    "for x in thislist:\n",
    "  print(x)\n",
    "print('\\n2nd method :')\n",
    "for i in range(len(thislist)):\n",
    "  print(thislist[i])\n",
    "\n",
    "print('\\n3rd method :')\n",
    "i = 0\n",
    "while i < len(thislist):\n",
    "  print(thislist[i])\n",
    "  i = i + 1\n",
    "\n",
    "print('\\n4th method :')\n",
    "[print(x) for x in thislist]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "disciplinary-supervisor",
   "metadata": {},
   "source": [
    "## List Comprehension  \n",
    "  \n",
    "List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.\n",
    "\n",
    "For example, assume we want to create a list of squares, like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "ranging-firewall",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = []\n",
    "for x in range(10):\n",
    "    squares.append(x**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "operational-curtis",
   "metadata": {},
   "source": [
    "**Note** : This creates (or overwrites) a variable named x that still exists after the loop completes.   \n",
    "We can calculate the list of squares without any side effects using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "liberal-crossing",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "squares = list(map(lambda x: x**2, range(10)))\n",
    "print(squares)\n",
    "#OR USING \n",
    "squares = [x**2 for x in range(10)]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "protecting-channels",
   "metadata": {},
   "source": [
    "A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it. For example, this listcomp combines the elements of two lists if they are not equal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "funny-renewal",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 3], [1, 4], [2, 3], [2, 1], [2, 4], [3, 1], [3, 4]]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[[x, y] for x in [1,2,3] for y in [3,1,4] if x != y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "olive-format",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 3], [1, 4], [2, 3], [2, 1], [2, 4], [3, 1], [3, 4]]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "combs = []\n",
    "for x in [1,2,3]:\n",
    "    for y in [3,1,4]:\n",
    "        if x != y:\n",
    "            combs.append([x, y])\n",
    "combs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sixth-respect",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}