Tuple, Set, Dictionary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary\n",
    "Python dictionary is an unordered collection of items. A dictionary has a key: value pair.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# empty dictionary\n",
    "my_dict = {}\n",
    "\n",
    "# dictionary with integer keys\n",
    "my_dict = {1: 'Apple', 2: 'Samsung', 3: 'Mi', 2: 'One plus'}\n",
    "\n",
    "# dictionary with mixed keys\n",
    "my_dict = {'name': 'random', 1: [2, 4, 3]}\n",
    "\n",
    "# using dict()\n",
    "my_dict = dict({1: 'Apple', 2: 'Samsung', 3: 'Mi', 2: 'One plus'})\n",
    "\n",
    "# from sequence having each item as a pair\n",
    "my_dict = dict([(1,'Apple'), (2,'Samsung')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'name':'IIT Bombay', 'year': 1958}\n",
    "\n",
    "\n",
    "print(my_dict['name'])\n",
    "\n",
    "\n",
    "print(my_dict.get('year'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Trying to access keys which doesn't exist throws error\n",
    "#my_dict.get('address')\n",
    "my_dict['city']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'name':'IIT Bombay', 'year': 1958}\n",
    "\n",
    "# update value\n",
    "my_dict['name'] = 'IIT Bombay, Powai'\n",
    "\n",
    "print(my_dict)\n",
    "\n",
    "# add item\n",
    "my_dict['city'] = 'Mumbai'  \n",
    "\n",
    "\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = {x: x*x for x in range(6)}\n",
    "\n",
    "# Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = {}\n",
    "for x in range(6):\n",
    "   squares[x] = x*x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Method | Descriptions |\n",
    "|--------|:---------|\n",
    "|clear() |\tRemoves all the elements from the dictionary |\n",
    "|copy()\t| Returns a copy of the dictionary |\n",
    "|fromkeys() |\tReturns a dictionary with the specified keys and values |\n",
    "|get()\t| Returns the value of the specified key |\n",
    "|items() |\tReturns a list containing the a tuple for each key value pair |\n",
    "|keys() |\tReturns a list contianing the dictionary's keys |\n",
    "|pop() |\tRemoves the element with the specified key |\n",
    "|popitem() |\tRemoves the last inserted key-value pair |\n",
    "|update() |\tUpdates the dictionary with the specified key-value pairs|\n",
    "|values() |\tReturns a list of all the values in the dictionary|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'IIT Bombay'\n",
    "if name == 'IIT Bombay':\n",
    "     print('Founded in 1958')\n",
    "        \n",
    "elif name == 'IIT Kharagpur':\n",
    "    print('Founded in 1950')\n",
    "    \n",
    "elif name == 'IIT Kanpur':\n",
    "    print('Founded in 1959')\n",
    "    \n",
    "elif name == 'IIT Delhi':\n",
    "    print('Founded in 1961')\n",
    "    \n",
    "elif name == 'IIT Madras':\n",
    "    print('Founded in 1959')\n",
    "    \n",
    "elif name == 'IIT Guwahati':\n",
    "    print('Founded in 1994')\n",
    "    \n",
    "else:\n",
    "    print(\"I don't know when it was founded\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "year = {'IIT Bombay': 'Founded in 1958',\n",
    "       'IIT Kharagpur': 'Founded in 1950',\n",
    "       'IIT Kanpur': 'Founded in 1959',\n",
    "       'IIT Delhi': 'Founded in 1961',\n",
    "       'IIT Madras': 'Founded in 1959',\n",
    "       'IIT Guwahati': 'Founded in 1994'}\n",
    "\n",
    "print(year.get('IIT Kharagpur', \"I don't know when it was founded\"))\n",
    "print(year.get('IIT Roorkee', \"I don't know when it was founded\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple\n",
    "In Python, a tuple is similar to a list. The difference between the two is that we cannot change the elements of a tuple once it is assigned whereas in a list, elements can be changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# empty tuple\n",
    "\n",
    "my_tuple = ()\n",
    "print(my_tuple)\n",
    "\n",
    "# tuple having integers\n",
    "\n",
    "my_tuple = (1, 2, 3)\n",
    "print(my_tuple)\n",
    "\n",
    "# tuple with mixed datatypes\n",
    "\n",
    "my_tuple = (1, \"Hello\", 3.4)\n",
    "print(my_tuple)\n",
    "\n",
    "\n",
    "# tuple can be created without parentheses\n",
    "# also called tuple packing\n",
    "\n",
    "my_tuple = 3, 4.6, \"string\"\n",
    "print(my_tuple)\n",
    "\n",
    "# tuple unpacking is also possible\n",
    "\n",
    "a, b, c = my_tuple\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# only parentheses is not enough\n",
    "\n",
    "my_tuple = (\"Mumbai\")\n",
    "print(type(my_tuple))\n",
    "\n",
    "# need a comma at the end\n",
    "\n",
    "my_tuple = (\"Mumbai\",)  \n",
    "print(type(my_tuple))\n",
    "\n",
    "# parentheses is optional\n",
    "\n",
    "my_tuple = \"Mumbai\",\n",
    "print(type(my_tuple))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = ('Hello', 2, 3, [6, 5])\n",
    "\n",
    "\n",
    "#my_tuple[1] = 9\n",
    "\n",
    "# but item of mutable element can be changed\n",
    "\n",
    "my_tuple[3][0] = 9\n",
    "print(my_tuple)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concatenation\n",
    "\n",
    "print((1, 2, 3) + (4, 5, 6))\n",
    "\n",
    "# Repeat\n",
    "\n",
    "print((\"Tuples are great\",) * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = ('i','i','t','b','o','m','b','a','y')\n",
    "\n",
    "# Count\n",
    "\n",
    "print(my_tuple.count('b'))\n",
    "\n",
    "# Index\n",
    "print(my_tuple.index('i'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set\n",
    "A set is an unordered collection of items. Every element is unique (no duplicates) and must be immutable (which cannot be changed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set of integers\n",
    "my_set = {1, 2, 3}\n",
    "print(my_set)\n",
    "\n",
    "# set of mixed datatypes\n",
    "my_set = {1.0, \"string\", (1, 2, 3)}\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize a with {}\n",
    "a = {}\n",
    "\n",
    "# check data type of a\n",
    "print(type(a))\n",
    "\n",
    "# initialize a with set()\n",
    "a = set()\n",
    "\n",
    "# check data type of a\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize my_set\n",
    "my_set = {1,3}\n",
    "print(my_set)\n",
    "\n",
    "\n",
    "#my_set[0]\n",
    "\n",
    "# add an element\n",
    "my_set.add(2)\n",
    "print(my_set)\n",
    "\n",
    "# add multiple elements\n",
    "\n",
    "my_set.update([2,3,4])\n",
    "print(my_set)\n",
    "\n",
    "# add list and set\n",
    "\n",
    "my_set.update([4,5,9], {1,6,8})\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some interesting things about Strings\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str = 'Python Workshop'\n",
    "print('str = ', str)\n",
    "\n",
    "#first character\n",
    "print('str[0] = ', str[0])\n",
    "\n",
    "#last character\n",
    "print('str[-1] = ', str[-1])\n",
    "\n",
    "#slicing 2nd to 5th character\n",
    "print('str[1:5] = ', str[1:5])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str[3] = 'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str1 = 'Hello'\n",
    "str2 ='World!'\n",
    "\n",
    "# using +\n",
    "print('str1 + str2 = ', str1 + str2)\n",
    "\n",
    "# using *\n",
    "print('str1 * 3 =', str1 * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"IITBombay\".lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"IITBombay\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Python Workshop\".split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Python-Workshop-2018\".split('-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['Python', 'Workshop']\n",
    "' '.join(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Python Workshop\".find(\"Wo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Python Workshop\".replace(\"W\",\"w\")"
   ]
  },
  {
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}