prodigiouspython/Chapter_1/5_Collection_Types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collection Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have many collection types in Python, `str`, `int` objects hold only value, but coming to collection types, we can have various objects stored in the collections.\n",
    "\n",
    "The Collection Types we have in Python are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Tuple\n",
    "* List \n",
    "* Set\n",
    "* Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Tuple is a ordered collection of objects and it is of fixed length and immutable, so the values in the tuple can not be changed nor added or removed. \n",
    "\n",
    "Tuples are generally used for small collections which we are sure about them from right before such as IP addresses and port numbers. Tuples are represented with parenthesis `()`\n",
    "\n",
    "Example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ip_address_port = (\"127.0.0.1\", 8080)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple with a single member needs to have a trailing comma, else the type of the variable would be the datatype of the member itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Proper way to create a single member tuple.\n",
    "single_member_tuple = (\"one\",)\n",
    "print(type(single_member_tuple))\n",
    "single_member_tuple = (\"one\",)\n",
    "print(type(single_member_tuple))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Improper way trying to create a single member tuple.\n",
    "single_member_tuple = \"one\"\n",
    "print(type(single_member_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List collection types are similar to tuples, the only difference would be that new objects can be created, removed or object's data can be modified 😉."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int_list = [1, 2, 3]\n",
    "string_list = [\"abc\", \"defghi\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A list can be empty:\n",
    "empty_list = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "objects in the list are not restricted to be of a particular datatype. let's see an example 👇."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_list = [1, \"abc\", True, 3.14, None]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "list can contain lists as objects too. These are called nested lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_list = [[1, 2, 3], [\"a\", \"b\", \"c\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The objects present in the list can be accessed by the index it is placed. The index starts from 0 👻."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [\"Iron man\", \"Thor\", \"Wonder Woman\", \"Wolverine\", \"Naruto\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list[0])\n",
    "print(my_list[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the `my_list`, we have 5 strings in the list, but in the below example, let's give a try to get the 100th index element which is not present in the `my_list` 🙄.\n",
    "\n",
    "As there is no 100th element, we would be seeing an `IndexError` exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(my_list[100])\n",
    "except IndexError as exc:\n",
    "    print(f\"👻 Ouch! we got into IndexError exception: {exc}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The question I have is, how do I get the 2nd element from the last 🤔? Should I find the length of the list and access the <length - 2>? Yup, it works 😉.\n",
    "\n",
    "But we have one good way to do it by negative index, example: `-2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access the 2nd element from the last.\n",
    "print(my_list[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We have a few methods of list that we can give it a try now 😎"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`append`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Append a new item to the list.\n",
    "# We use append method of the list.\n",
    "my_list.append(\"Zoro\")\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`remove`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove the item present in the list.\n",
    "# We use remove method of the list.\n",
    "# If there's no object that we are trying to remove in the list, then ValueError would be raised.\n",
    "try:\n",
    "    my_list.remove(\"Zoro\")\n",
    "    print(my_list)\n",
    "except ValueError as exc:\n",
    "    print(f\"Caught ValueError: {exc}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`insert`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insert a object at a particular index.\n",
    "# We use insert method of the list.\n",
    "my_list.insert(1, \"Super Man\")\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`reverse`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse the objects in the list.\n",
    "# we use reverse method of the list.\n",
    "my_list.reverse()\n",
    "print(my_list)\n",
    "\n",
    "# revert to the actual order\n",
    "my_list.reverse()\n",
    "\n",
    "# We have one more method too for this 🙃\n",
    "# The indexing of the list would be in the form of list[start: end: step]\n",
    "# We will use step as -1 to get the elements in reverse order 😉\n",
    "print(my_list[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`index`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Index of an object in the list.\n",
    "# we use index method of the list.\n",
    "# raises a ValueError, if no given object is found in the list.\n",
    "try:\n",
    "    print(my_list.index(\"Naruto\"))\n",
    "except ValueError as exc:\n",
    "    print(f\"Caught ValueError: {exc}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pop`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pop is used to remove and return the element present at the last in the list(index=-1) by default.\n",
    "# When index argument is passed, it would remove and return the element at that index.\n",
    "# raises IndexError when no object is present at the given Index.\n",
    "try:\n",
    "    last_element = (\n",
    "        my_list.pop()\n",
    "    )  # can be passed index argument value, if required to pop at a specific index.\n",
    "    print(last_element)\n",
    "except IndexError as exc:\n",
    "    print(f\"Caught IndexError: {exc}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set is collection of unique items, the items does not follow insertion order.\n",
    "\n",
    "Defining an set is pretty similar to a list or tuple, it is enclosed in `{}`\n",
    "\n",
    "PS 🔔: If we need to have a empty set, `{}` won't create a set, it creates a empty dictionary instead. So we need to create a empty set by using `set()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "anime = {\"Dragon ball\", \"One Piece\", \"Death Note\", \"Full Metal Alchemist\", \"Naruto\"}\n",
    "print(anime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`add`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "anime.add(\"Tokyo Ghoul\")\n",
    "print(anime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`remove`\n",
    "\n",
    "remove method of set can be used to remove a particular object from the set, if the object is not present, KeyError would be raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    anime.remove(\"Tokyo Ghoul\")\n",
    "    print(anime)\n",
    "except KeyError as exc:\n",
    "    print(\n",
    "        f\"Caught KeyError as there's given anime series present in the anime set: {exc}\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in few other languages, we have hashmaps, Dictionaries in python are similar. It has unique Key - Value pairs.\n",
    "\n",
    "The Key and Value can be of any object. Each Key-Value pair is separated by a `,`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "anime_protagonist = {\n",
    "    \"Dragon Ball\": \"Goku\",\n",
    "    \"One Piece\": \"Luffy\",\n",
    "    \"Death Note\": \"Yagami Light\",\n",
    "    \"Full Metal Alchemist\": \"Edward Elric\",\n",
    "    \"Naruto\": \"Naruto\",\n",
    "}\n",
    "print(anime_protagonist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the values of the dictionary by `<dictionary>[<key>]`.\n",
    "If there's no `<key>` in the dictionary, we would be seeing an KeyError 🔑❌"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(anime_protagonist[\"Dragon Ball\"])\n",
    "except KeyError as exc:\n",
    "    print(\n",
    "        f\"👻 Ouch, KeyError has been raised as no given key is found in the dictionary: {exc}\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterate over keys, values and both in the dictionary 🐇"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keys\n",
    "print(\"===Keys===\")\n",
    "for my_key in anime_protagonist.keys():\n",
    "    print(my_key)\n",
    "\n",
    "# Values\n",
    "print(\"===Values===\")\n",
    "for my_value in anime_protagonist.values():\n",
    "    print(my_value)\n",
    "\n",
    "# Key-Values\n",
    "print(\"===Key-Values===\")\n",
    "for my_key, my_value in anime_protagonist.items():\n",
    "    print(f\"{my_key} : {my_value}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PS 🔔: Are dictionaries ordered collection🤔?\n",
    "\n",
    "From Python 3.7 dictionaries follow insertion order 😎\n",
    "\n",
    "In python versions older than 3.7, the insertion of items is not ordered🙄. No problem 🙃, we still have OrderedDict(present in collections module) `from collections import OrderedDict` which does the same 😉"
   ]
  }
 ],
 "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}