2_strings_and_lists/03_lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit 2\n",
    "## Lists\n",
    "\n",
    "**Content:**\n",
    "- Definition and Characteristics\n",
    "- Nested Lists\n",
    "- List Indexing\n",
    "- Indexing in Nested Lists\n",
    "- List Slicing\n",
    "- List Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists - Definition and Characteristics\n",
    "\n",
    "Definition:\n",
    "- List is a collection of things enclosed with square brackets and seperated by commas.\n",
    "- It is a sequence datatype which is used to store the collection of data.\n",
    "\n",
    "Characteristics:\n",
    "- Lists are mutable\n",
    "- Lists are heterogeneous, i.e., they can have multiple datatypes.\n",
    "- They can be nested"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of a: <class 'list'> | Length of a: 0 | Content of a: []\n",
      "Type of b: <class 'list'> | Length of b: 4 | Content of b: [1, 2, 3, 4]\n",
      "Type of c: <class 'list'> | Length of c: 9 | Content of c: [1.1, 1.2, 1.3, 2.1, 2.2, 2.3, 3.1, 3.2, 3.3]\n",
      "Type of d: <class 'list'> | Length of d: 4 | Content of d: ['D', 'e', 'm', 'o']\n",
      "Type of e: <class 'list'> | Length of e: 5 | Content of e: ['Hi', 1, 1.1, 'A', True]\n"
     ]
    }
   ],
   "source": [
    "# Lists - Introduction\n",
    "\n",
    "# Empty List\n",
    "a = []\n",
    "# List of Integers\n",
    "b = [1, 2, 3, 4]\n",
    "# List of Float\n",
    "c = [1.1, 1.2, 1.3, 2.1, 2.2, 2.3, 3.1, 3.2, 3.3]\n",
    "# List of char\n",
    "d = ['D', 'e', 'm', 'o']\n",
    "# List of multiple datatypes\n",
    "e = [\"Hi\", 1, 1.1, \"A\", True]\n",
    "\n",
    "print(f\"Type of a: {type(a)} | Length of a: {len(a)} | Content of a: {a}\")\n",
    "print(f\"Type of b: {type(b)} | Length of b: {len(b)} | Content of b: {b}\")\n",
    "print(f\"Type of c: {type(c)} | Length of c: {len(c)} | Content of c: {c}\")\n",
    "print(f\"Type of d: {type(d)} | Length of d: {len(d)} | Content of d: {d}\")\n",
    "print(f\"Type of e: {type(e)} | Length of e: {len(e)} | Content of e: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nested Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type of a: <class 'list'> | Length of a: 6 | Content of a: [1, 2, 3, [4, 5, 6], 7, 8]\n"
     ]
    }
   ],
   "source": [
    "# Nested Lists\n",
    "\n",
    "# Lists\n",
    "a = [1, 2, 3, [4, 5, 6,], 7, 8]\n",
    "\n",
    "print(f\"Type of a: {type(a)} | Length of a: {len(a)} | Content of a: {a}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Indexing\n",
    "\n",
    "Indexing in list works same as that of string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive Indexing\n",
      "Index 0: a\n",
      "Index 1: b\n",
      "Index 2: c\n",
      "Index 3: d\n",
      "Negative Indexing\n",
      "Index -1: d\n",
      "Index -2: c\n",
      "Index -3: b\n",
      "Index -4: a\n"
     ]
    }
   ],
   "source": [
    "# List Indexing\n",
    "\n",
    "# Lists\n",
    "a = ['a', 'b', 'c', 'd']\n",
    "\n",
    "# Positive Index\n",
    "print(\"Positive Indexing\")\n",
    "print(f\"Index 0: {a[0]}\")\n",
    "print(f\"Index 1: {a[1]}\")\n",
    "print(f\"Index 2: {a[2]}\")\n",
    "print(f\"Index 3: {a[3]}\")\n",
    "\n",
    "# Negative Index\n",
    "print(\"Negative Indexing\")\n",
    "print(f\"Index -1: {a[-1]}\")\n",
    "print(f\"Index -2: {a[-2]}\")\n",
    "print(f\"Index -3: {a[-3]}\")\n",
    "print(f\"Index -4: {a[-4]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexing in Nested Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List: [1, 2, 3, [4, 5, 6], 7, 8]\n",
      "Index [3]: [4, 5, 6]\n",
      "Index [3][0]: 4\n",
      "Index [3][1]: 5\n",
      "Index [3][2]: 6\n"
     ]
    }
   ],
   "source": [
    "# Indexing in Nested Lists\n",
    "\n",
    "# Lists\n",
    "a = [1, 2, 3, [4, 5, 6,], 7, 8]\n",
    "\n",
    "print(f\"List: {a}\")\n",
    "print(f\"Index [3]: {a[3]}\")\n",
    "print(f\"Index [3][0]: {a[3][0]}\")\n",
    "print(f\"Index [3][1]: {a[3][1]}\")\n",
    "print(f\"Index [3][2]: {a[3][2]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Slicing\n",
    "\n",
    "Slicing in Lists works same as that of strings, i.e., list[start : end : step]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list[1::2]: [2, 7, 15, 89]\n",
      "list[1]: 2\n"
     ]
    }
   ],
   "source": [
    "# List Slicing\n",
    "\n",
    "# Lists\n",
    "a = [1, 2, 5, 7, 9, 15, 79, 89, 100]\n",
    "\n",
    "\n",
    "print(f\"list[1::2]: {a[1::2]}\")\n",
    "print(f\"list[1]: {a[1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Operations\n",
    "\n",
    "We can perform the following operations on a python list:\n",
    "- len() - To get the length of a list\n",
    "- append() - To add an element at the end of a list\n",
    "- insert() - To insert an element at the specified index\n",
    "- count() - To count the number of occurences of a particular element\n",
    "- remove() - To remove an element from the list (If repeated, first occurence is removed)\n",
    "- pop() - To remove an element from the list at specified index\n",
    "- max() - To get the element with maximum value in the list\n",
    "- min() - To get the element with minimum value in the list\n",
    "- reverse() - To reverse the list\n",
    "- sort() - To sort the elements in list in ascending order\n",
    "- clear() - To clear or remove all elements in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of a: 5\n",
      "Append 9 to a: [1, 2, 3, 4, 5, 9]\n",
      "Append 11 to a: [1, 2, 3, 4, 5, 9, 11]\n",
      "Inserted an element at index 2 in list: [1, 2, 'Inserted Index 2', 3, 4, 5, 9, 11]\n",
      "No. of occurences of 'a' in list(['a', 'b', 'c', 'd', 'a', 'b']): 2\n",
      "Removed 'a' in list: ['b', 'c', 'd', 'a', 'b']\n",
      "Element at index 3 removed(pop): ['b', 'c', 'd', 'b']\n",
      "Maximum in the list: d\n",
      "Minimum in the list: b\n",
      "List: [1, 2, 'Inserted Index 2', 3, 4, 5, 9, 11]\n",
      "Reversed list: [11, 9, 5, 4, 3, 'Inserted Index 2', 2, 1]\n",
      "Sorted list in ascending order: ['b', 'b', 'c', 'd']\n",
      "Sorted list in descending order: ['d', 'c', 'b', 'b']\n",
      "Cleared List: []\n"
     ]
    }
   ],
   "source": [
    "# List Operations\n",
    "\n",
    "# Lists\n",
    "a = [1, 2, 3, 4, 5]\n",
    "b = ['a', 'b', 'c', 'd', 'a', 'b']\n",
    "\n",
    "# Operations\n",
    "# len()\n",
    "print(f\"Length of a: {len(a)}\")\n",
    "\n",
    "# append()\n",
    "a.append(9)\n",
    "print(f\"Append 9 to a: {a}\")\n",
    "a.append(11)\n",
    "print(f\"Append 11 to a: {a}\")\n",
    "\n",
    "# insert()\n",
    "a.insert(2, \"Inserted Index 2\")\n",
    "print(f\"Inserted an element at index 2 in list: {a}\")\n",
    "\n",
    "# count()\n",
    "print(f\"No. of occurences of 'a' in list({b}): {b.count('a')}\")\n",
    "\n",
    "# remove()\n",
    "b.remove('a')\n",
    "print(f\"Removed 'a' in list: {b}\")\n",
    "\n",
    "# pop()\n",
    "b.pop(3)\n",
    "print(f\"Element at index 3 removed(pop): {b}\")\n",
    "\n",
    "# max()\n",
    "print(f\"Maximum in the list: {max(b)}\")\n",
    "\n",
    "# min()\n",
    "print(f\"Minimum in the list: {min(b)}\")\n",
    "\n",
    "# reverse()\n",
    "print(f\"List: {a}\")\n",
    "a.reverse()\n",
    "print(f\"Reversed list: {a}\")\n",
    "\n",
    "# sort()\n",
    "b.sort()\n",
    "print(f\"Sorted list in ascending order: {b}\")\n",
    "b.sort(reverse=True)\n",
    "print(f\"Sorted list in descending order: {b}\")\n",
    "\n",
    "# clear()\n",
    "a.clear()\n",
    "print(f\"Cleared List: {a}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assignment - 1\n",
    "\n",
    "abc = [\"Apple\", 2, 5.5, [5, 9, \"Orange\", 6.9], 10, 11.5]\n",
    "\n",
    "To obtain Outputs (using positive and negative indexing):\n",
    "- 2\n",
    "- [5, 9, \"Orange, 6.9]\n",
    "- Orange\n",
    "- 5.5, [5, 9, \"Orange\", 6.9], 10\n",
    "- Reverse the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output - 1 (+ve indexing): 2\n",
      "Output - 1 (-ve indexing): 2\n",
      "Output - 2 (+ve indexing): [5, 9, 'Orange', 6.9]\n",
      "Output - 2 (-ve indexing): [5, 9, 'Orange', 6.9]\n",
      "Output - 3 (+ve indexing): Orange\n",
      "Output - 3 (-ve indexing): Orange\n",
      "Output - 4 (+ve indexing): [5.5, [5, 9, 'Orange', 6.9], 10]\n",
      "Output - 4 (-ve indexing): [5.5, [5, 9, 'Orange', 6.9], 10]\n",
      "Output - 5 (+ve indexing): [11.5, 10, [5, 9, 'Orange', 6.9], 5.5, 2, 'Apple']\n",
      "Output - 5 (-ve indexing): [11.5, 10, [5, 9, 'Orange', 6.9], 5.5, 2, 'Apple']\n"
     ]
    }
   ],
   "source": [
    "# List\n",
    "abc = [\"Apple\", 2, 5.5, [5, 9, \"Orange\", 6.9], 10, 11.5]\n",
    "\n",
    "# Outputs\n",
    "print(f\"Output - 1 (+ve indexing): {abc[1]}\")\n",
    "print(f\"Output - 1 (-ve indexing): {abc[-5]}\")\n",
    "print(f\"Output - 2 (+ve indexing): {abc[3]}\")\n",
    "print(f\"Output - 2 (-ve indexing): {abc[-3]}\")\n",
    "print(f\"Output - 3 (+ve indexing): {abc[3][2]}\")\n",
    "print(f\"Output - 3 (-ve indexing): {abc[-3][-2]}\")\n",
    "print(f\"Output - 4 (+ve indexing): {abc[2:5]}\")\n",
    "print(f\"Output - 4 (-ve indexing): {abc[-4:-1]}\")\n",
    "print(f\"Output - 5 (+ve indexing): {abc[5::-1]}\")\n",
    "print(f\"Output - 5 (-ve indexing): {abc[-1::-1]}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.11.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}