data_types.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "841ec1c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "# notebook is a collection of cells\n",
    "# to run a cell, press Shift+enter\n",
    "\n",
    "print(\"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34ccf4dc",
   "metadata": {},
   "source": [
    "# Datatypes in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bfcf03fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 12"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44cbd743",
   "metadata": {},
   "source": [
    "- text : str\n",
    "- numeric: int (-1, -2, 0,1,2,....), float (1.23456, 23.004), complex (1 + 7i)\n",
    "- sequence: list, tuple, range\n",
    "- mapping: dict\n",
    "- set: set\n",
    "- boolean: bool (True/False)\n",
    "- none type: NoneType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "798c9907",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'grapes', 'apple', 'banana'}\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "x = [\"apple\", \"banana\", \"grapes\", \"apple\"]\n",
    "z = (\"apple\", \"banana\", \"grapes\")\n",
    "y = set(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb25bb13",
   "metadata": {},
   "outputs": [],
   "source": [
    "chemical_names = [1,2,3,4,5,6,7,8,9,10]\n",
    "chemical_usage = [\"aerospace\", \"health\", \"\", \"\",\"\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c055b437",
   "metadata": {},
   "outputs": [],
   "source": [
    "# reserved keyword\n",
    "dict_ = {\"Ram\": [68, 70, 89, 76, 56], \"Armaan\": [56, 90, 76, 56, 90]}        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ef918f66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[68, 70, 89, 76, 56]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_[\"Ram\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07ac506c",
   "metadata": {},
   "source": [
    "# getting the data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6ceb0cff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "x = \"5\"\n",
    "# arguments/params: whatever input u r giving to your function\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7351d64c",
   "metadata": {},
   "source": [
    "# setting the data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7e494807",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "x = \"hello world !!! $$$\"\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "16145d9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = 20\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "11f88d63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "x = 1+7j\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "206ce99e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 20.556\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b1c5acfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "x = [\"apple\", \"banana\", 12]\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "64d29b24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "x = (\"apple\", \"banana\", \"grapes\", 12)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "2e07ea31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 6)\n",
      "<class 'range'>\n"
     ]
    }
   ],
   "source": [
    "x = range(6)\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "4dba3b65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{'name': 'John', 'age': 36}\n",
      "{'class1': ['A', 'B', 'C'], 'class2': ['D', 'E', 'F', 'G'], 'class3': []}\n",
      "{'class1': ['A', 'B', 'C'], 'class2': ['D', 'E', 'F', 'G'], 'class3': []}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "x = dict(name = \"John\", age = 36)\n",
    "print(type(x))\n",
    "print(x)\n",
    "\n",
    "# in dictionaries, the values for a key could be a list/tuple/dict\n",
    "x = dict(class1 = [\"A\", 'B', 'C'], class2 = [\"D\", \"E\", \"F\", \"G\"], class3 = [])\n",
    "print(x)\n",
    "\n",
    "# in dictionaries, lists can't be keys (logically)\n",
    "x = {(\"class1\") : [\"A\", 'B', 'C'], (\"class2\") : [\"D\", \"E\", \"F\", \"G\"], (\"class3\") : []}\n",
    "print(x)\n",
    "print(type(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1cf77625",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 'banana', 'grapes', 20.5, 'apple'}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "x = set((\"apple\", \"banana\", \"grapes\", \"apple\", 1, 20.5))\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3231ad7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = bool(5)\n",
    "print(type(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "14aaea61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "x = bool(4==5)\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6346c4da",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "02b734a7",
   "metadata": {},
   "source": [
    "# Typecasting: converting from one data type to another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5845cd88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "1604367969168\n",
      "1604447104752\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "x = 20\n",
    "print(type(x))\n",
    "\n",
    "# for getting memory address of a variable: id(var_name)\n",
    "print(id(x))\n",
    "x = str(x)\n",
    "print(id(x))\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db3eb292",
   "metadata": {},
   "source": [
    "# String datatype "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4f70c69",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'string'\n",
    "x = \"string\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69db3851",
   "metadata": {},
   "source": [
    "In Python, Strings are arrays of bytes representing Unicode characters. A string is a collection of one or more characters put in a single quote, double-quote or triple quote. In python there is no character data type, a character is a string of length one. It is represented by str class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dde8bfa",
   "metadata": {},
   "source": [
    "Creating String\n",
    "\n",
    "- Strings in Python can be created using single quotes or double quotes or even triple quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0aa7d34e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String with the use of Single Quotes: Welcome to the Geeks World\n",
      "\n",
      "String with the use of Double Quotes: \n",
      "I'm a Geek\n",
      "<class 'str'>\n",
      "\n",
      "String with the use of Triple Quotes: \n",
      "I'm a Geek and I live in a world of \"Geeks\"\n",
      "<class 'str'>\n",
      "\n",
      "Creating a multiline String: \n",
      "Geeks\n",
      "            geek\n",
      "\t\t\tFor\n",
      "\t\t\tLife\n"
     ]
    }
   ],
   "source": [
    "# Python Program for\n",
    "# Creation of String\n",
    "\t\n",
    "# Creating a String\n",
    "# with single Quotes\n",
    "String1 = 'Welcome to the Geeks World'\n",
    "print(\"String with the use of Single Quotes: \", end='')\n",
    "print(String1)\n",
    "\t\n",
    "# Creating a String\n",
    "# with double Quotes\n",
    "String1 = \"I'm a Geek\"\n",
    "print(\"\\nString with the use of Double Quotes: \")\n",
    "print(String1)\n",
    "print(type(String1))\n",
    "\t\n",
    "# Creating a String\n",
    "# with triple Quotes\n",
    "String1 = '''I'm a Geek and I live in a world of \"Geeks\"'''\n",
    "print(\"\\nString with the use of Triple Quotes: \")\n",
    "print(String1)\n",
    "print(type(String1))\n",
    "\n",
    "# Creating String with triple\n",
    "# Quotes allows multiple lines\n",
    "String1 = '''Geeks\n",
    "            geek\n",
    "\t\t\tFor\n",
    "\t\t\tLife'''\n",
    "print(\"\\nCreating a multiline String: \")\n",
    "print(String1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0443e671",
   "metadata": {},
   "source": [
    "Accessing elements of String\n",
    "\n",
    "- In Python, individual characters of a String can be accessed by using the method of Indexing. Indexing allows negative address references to access characters from the back of the String, e.g. -1 refers to the last character, -2 refers to the second last character and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "670d1b29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i\n",
      "a\n",
      "b\n",
      "m\n",
      "u\n",
      "m\n"
     ]
    }
   ],
   "source": [
    "x = \"mumbai\"   #indexing from 0 to 5 since the string has 5 characters\n",
    "print(x[-1])\n",
    "\n",
    "print(x[-2])\n",
    "print(x[-3])\n",
    "print(x[-4])\n",
    "print(x[-5])\n",
    "print(x[-6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "47135a83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[200]\n",
      "200\n"
     ]
    }
   ],
   "source": [
    "x=[200]\n",
    "print(x)\n",
    "print(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "cb6fd11f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial String: \n",
      "GeeksForGeeks\n",
      "\n",
      "First character of String is: \n",
      "G\n",
      "F\n",
      "\n",
      "Last character of String is: \n",
      "s\n",
      "G\n"
     ]
    }
   ],
   "source": [
    "# Python Program to Access\n",
    "# characters of String\n",
    "\t\n",
    "String1 = \"GeeksForGeeks\"\n",
    "print(\"Initial String: \")\n",
    "print(String1)\n",
    "\t\n",
    "# Printing First character\n",
    "print(\"\\nFirst character of String is: \")\n",
    "print(String1[0])\n",
    "print(String1[5])\n",
    "\t\n",
    "# Printing Last character\n",
    "print(\"\\nLast character of String is: \")\n",
    "print(String1[-1])\n",
    "print(String1[-5])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "096e5b83",
   "metadata": {},
   "source": [
    "# List datatype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c023852",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [\"a\", \"b\", \"c\"]   #array: collection of elements with same datatype\n",
    "x = [\"a\", 1, 3.5]     # list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00e34b82",
   "metadata": {},
   "source": [
    "Lists are just like the arrays, declared in other languages which is a ordered collection of data. It is very flexible as the items in a list do not need to be of the same type.\n",
    " \n",
    "\n",
    "Creating List\n",
    "\n",
    "- Lists in Python can be created by just placing the sequence inside the square brackets[]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "5473ca24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "li = []\n",
    "print(li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "6da22725",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial blank List: \n",
      "[]\n",
      "\n",
      "List with the use of String: \n",
      "['GeeksForGeeks']\n",
      "\n",
      "List containing multiple values: \n",
      "Geeks\n",
      "For\n",
      "Lemons\n",
      "printing 3rd character from first element k\n",
      "Lemons\n",
      "\n",
      "Multi-Dimensional List: \n",
      "['Geeks', 'For']\n",
      "['Lemons']\n",
      "\n",
      " checking multi-dimensional lists\n",
      "List2[1] ['Lemons']\n",
      "List2[1][0] Lemons\n",
      "List2[1][0][0] L\n",
      "k\n"
     ]
    }
   ],
   "source": [
    "# Python program to demonstrate\n",
    "# Creation of List\n",
    "\t\n",
    "# Creating a List\n",
    "List = []\n",
    "print(\"Initial blank List: \")\n",
    "print(List)\n",
    "\t\n",
    "# Creating a List with\n",
    "# the use of a String\n",
    "List = ['GeeksForGeeks']                                     #appending elements to the list\n",
    "print(\"\\nList with the use of String: \")\n",
    "print(List)\n",
    "\n",
    "\n",
    "\t\n",
    "# Creating a List with\n",
    "# the use of multiple values\n",
    "List = [\"Geeks\", \"For\", \"Lemons\"]\n",
    "print(\"\\nList containing multiple values: \")\n",
    "print(List[0])\n",
    "print(List[1])\n",
    "print(List[2])\n",
    "print(\"printing 3rd character from first element\", List[0][3])                 #List[0][3]:Geeks[3] \n",
    "\n",
    "print(List[-1])\n",
    "\n",
    "# print(List[-4])\n",
    "\t\n",
    "# Creating a Multi-Dimensional List\n",
    "# (By Nesting a list inside a List)\n",
    "List2 = [['Geeks', 'For'], ['Lemons']]                #l = [ [1,2,3], [4], [5,6]]\n",
    "print(\"\\nMulti-Dimensional List: \")\n",
    "print(List2[0])\n",
    "print(List2[1])\n",
    "\n",
    "print(\"\\n checking multi-dimensional lists\")\n",
    "print(\"List2[1]\", List2[1])\n",
    "print(\"List2[1][0]\", List2[1][0])\n",
    "print(\"List2[1][0][0]\", List2[1][0][0])                                 #list2[1]: []\n",
    "print(List2[0][0][3])                                                     \n",
    "#   [['Geeks', 'For'], ['Lemons']]       \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "1fde94dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "li first element '\n",
      "li second element \"\n",
      "li third element  ''\"\"  \n",
      "li third element '\n"
     ]
    }
   ],
   "source": [
    "li = [\"'\", '\"', ''' ''\"\"  '''] \n",
    "print(\"li first element\", li[0])\n",
    "print(\"li second element\", li[1])\n",
    "print(\"li third element\", li[2])\n",
    "print(\"li third element\", li[2][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "389414ab",
   "metadata": {},
   "source": [
    "Accessing elements of List\n",
    "- In order to access the list items refer to the index number. Use the index operator [ ] to access an item in a list. In Python, negative sequence indexes represent positions from the end of the array. Instead of having to compute the offset as in List[len(List)-3], it is enough to just write List[-3]. Negative indexing means beginning from the end, -1 refers to the last item, -2 refers to the second-last item, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e0c6ff7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accessing element from the list\n",
      "Geeks\n",
      "Lemons\n",
      "Accessing element using negative indexing\n",
      "Lemons\n",
      "Geeks\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Python program to demonstrate\n",
    "# accessing of element from list\n",
    "\t\n",
    "# Creating a List with\n",
    "# the use of multiple values\n",
    "List = [\"Geeks\", \"For\", \"Lemons\"]\n",
    "\t\n",
    "# accessing a element from the\n",
    "# list using index number\n",
    "print(\"Accessing element from the list\")\n",
    "print(List[0])\n",
    "\n",
    "print(List[2])\n",
    "\n",
    "# accessing a element using\n",
    "# negative indexing\n",
    "print(\"Accessing element using negative indexing\")\n",
    "\t\n",
    "# print the last element of list\n",
    "print(List[-1])\n",
    "\t\n",
    "# print the third last element of list\n",
    "print(List[-3])\n",
    "\n",
    "print(bool(List[0]==List[-3]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "470c5880",
   "metadata": {},
   "source": [
    "# appending item to list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "eee2e5ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "l = [1]\n",
    "# l = [2]\n",
    "x = 5\n",
    "print(l)\n",
    "l.append(2)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "297aa2db",
   "metadata": {},
   "outputs": [],
   "source": [
    "# case-sernsitivity in python\n",
    "True true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "4065afc9",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_18788\\17823663.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mY\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "Y=10                                                                                              \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "2ca51749",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 3]\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3]\n",
    "l.append(3)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c1e6585",
   "metadata": {},
   "source": [
    "# extend in list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "30eee07b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# all the elements of 'iterable' are added to the end of your original list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "609743f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry', 'Ford', 'Maruti']\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'cherry']\n",
    "cars = ['Ford', 'Maruti']\n",
    "\n",
    "fruits.extend(cars)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "aafb8f52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hindi', 'Kannada', 'English', 'German', 'French']\n"
     ]
    }
   ],
   "source": [
    "languages = ['Hindi', 'Kannada']\n",
    "other_languages = ['English', 'German', 'French']\n",
    "languages.extend(other_languages)\n",
    "print(languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b77c9fc",
   "metadata": {},
   "source": [
    "# Tuple datatype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e13d83e4",
   "metadata": {},
   "source": [
    "Just like list, tuple is also an ordered collection of Python objects. The only difference between tuple and list is that tuples are immutable i.e. tuples cannot be modified after it is created. It is represented by tuple class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c623c975",
   "metadata": {},
   "source": [
    "Creating Tuple\n",
    "\n",
    "- In Python, tuples are created by placing a sequence of values separated by ‘comma’ with or without the use of parentheses for grouping of the data sequence. Tuples can contain any number of elements and of any datatype (like strings, integers, list, etc.).\n",
    "\n",
    "- Note: Tuples can also be created with a single element, but it is a bit tricky. Having one element in the parentheses is not sufficient, there must be a trailing ‘comma’ to make it a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "bac9326e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "t = (1,2,3)\n",
    "print(type(t))\n",
    "\n",
    "# t.append(4)\n",
    "t = (4,5,6)                 # created a new tuple 't'\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "17a24da5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial empty Tuple: \n",
      "()\n",
      "\n",
      "Tuple with the use of String: \n",
      "('Geeks', 'For')\n",
      "\n",
      "Tuple using List: \n",
      "<class 'tuple'>\n",
      "x: (1, 2, 4, 5, 6)\n",
      "list1: [1, 2, 4, 5, 6]\n",
      "\n",
      "Tuple with the use of function: \n",
      "('G', 'e', 'e', 'k', 's')\n",
      "\n",
      "Tuple with nested tuples: \n",
      "((0, 1, 2, 3), ('python', 'geek'))\n"
     ]
    }
   ],
   "source": [
    "# Python program to demonstrate\n",
    "# creation of Set\n",
    "\t\n",
    "# Creating an empty tuple\n",
    "Tuple1 = ()\n",
    "print(\"Initial empty Tuple: \")\n",
    "print (Tuple1)\n",
    "\t\n",
    "# Creating a Tuple with\n",
    "# the use of Strings\n",
    "Tuple1 = ('Geeks', 'For')\n",
    "print(\"\\nTuple with the use of String: \")\n",
    "print(Tuple1)\n",
    "\t\n",
    "# Creating a Tuple with\n",
    "# the use of list\n",
    "list1 = [1, 2, 4, 5, 6]\n",
    "print(\"\\nTuple using List: \")\n",
    "x = tuple(list1)\n",
    "print(type(x))\n",
    "print(\"x:\", x)\n",
    "print(\"list1:\", list1)\n",
    "\n",
    "# Creating a Tuple with the\n",
    "# use of built-in function\n",
    "Tuple1 = tuple('Geeks')\n",
    "print(\"\\nTuple with the use of function: \")\n",
    "print(Tuple1)\n",
    "\n",
    "# Creating a Tuple\n",
    "# with nested tuples\n",
    "Tuple1 = (0, 1, 2, 3)\n",
    "Tuple2 = ('python', 'geek')\n",
    "Tuple3 = (Tuple1, Tuple2)                                # ( (), (), ())\n",
    "print(\"\\nTuple with nested tuples: \")\n",
    "print(Tuple3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "54d88924",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Geeks', 'Geeks')\n",
      "k: ('G', 'e', 'e', 'k', 's')\n",
      "('G', 'e', 'e', 'k', 's')\n"
     ]
    }
   ],
   "source": [
    "t = (\"Geeks\", \"Geeks\")                       #tuples can store duplicate values\n",
    "print(t)\n",
    "k = ('G', 'e', 'e', 'k', 's')\n",
    "print(\"k:\", k)\n",
    "s = tuple(\"Geeks\")\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d91af83",
   "metadata": {},
   "source": [
    "Note – Creation of Python tuple without the use of parentheses is known as Tuple Packing.\n",
    "\n",
    "Accessing elements of Tuple\n",
    "- In order to access the tuple items refer to the index number. Use the index operator [ ] to access an item in a tuple. The index must be an integer. Nested tuples are accessed using nested indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "d46b00f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t = tuple([1,2,3,4,5])\n",
    "print(t)\n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "aa490cdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "our tuple is: (1, 2, 3, 4, 5)\n",
      "First element of tuple\n",
      "1\n",
      "\n",
      "Last element of tuple\n",
      "5\n",
      "\n",
      "Third last element of tuple\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Python program to\n",
    "# demonstrate accessing tuple\n",
    "\n",
    "tuple1 = tuple([1, 2, 3, 4, 5])\n",
    "print(\"our tuple is:\", tuple1)\n",
    "\n",
    "# Accessing element using indexing\n",
    "print(\"First element of tuple\")\n",
    "print(tuple1[0])\n",
    "\n",
    "# Accessing element from last\n",
    "# negative indexing\n",
    "print(\"\\nLast element of tuple\")\n",
    "print(tuple1[-1])\n",
    "\n",
    "print(\"\\nThird last element of tuple\")\n",
    "print(tuple1[-3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "797d3ab1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Geeks\n",
      "<class 'str'>\n",
      "('G', 'e', 'e', 'k', 's')\n",
      "('Geeks',)\n",
      "<class 'int'>\n",
      "123\n",
      "(123,)\n"
     ]
    }
   ],
   "source": [
    "t = (\"Geeks\")\n",
    "print(t)\n",
    "print(type(t))\n",
    "t = tuple(\"Geeks\")\n",
    "print(t)\n",
    "t = tuple([\"Geeks\"])\n",
    "print(t)\n",
    "\n",
    "\n",
    "z = (123)\n",
    "print(type(z))\n",
    "# z = tuple(z)\n",
    "print(z)\n",
    "z = tuple([z])\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41248f6d",
   "metadata": {},
   "source": [
    "# Boolean Datatype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa94eaea",
   "metadata": {},
   "source": [
    "Data type with one of the two built-in values, True or False. Boolean objects that are equal to True are truthy (true), and those equal to False are falsy (false). But non-Boolean objects can be evaluated in Boolean context as well and determined to be true or false. It is denoted by the class bool.\n",
    "\n",
    "Note – True and False with capital ‘T’ and ‘F’ are valid booleans otherwise python will throw an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0d740425",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "<class 'bool'>\n",
      "<class 'bool'>\n",
      "True case True\n",
      "False case False\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'true' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_7724\\4011659279.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"False case\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'true' is not defined"
     ]
    }
   ],
   "source": [
    "# Python program to\n",
    "# demonstrate boolean type\n",
    "\n",
    "print(type(True))\n",
    "print(type(False))\n",
    "\n",
    "x = bool(5)\n",
    "print(type(x))\n",
    "print(\"True case\", x)\n",
    "\n",
    "x = bool(4==5)\n",
    "print(\"False case\", x)\n",
    "\n",
    "print(type(true))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e941d98",
   "metadata": {},
   "source": [
    "# Set datatype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a85f9c5",
   "metadata": {},
   "source": [
    "In Python, Set is an unordered collection of data type that is iterable, mutable and has no duplicate elements. The order of elements in a set is undefined though it may consist of various elements.\n",
    "\n",
    "Creating Sets\n",
    "Sets can be created by using the built-in set() function with an iterable object or a sequence by placing the sequence inside curly braces, separated by ‘comma’. Type of elements in a set need not be the same, various mixed-up data type values can also be passed to the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9a419da5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial blank Set: \n",
      "set()\n",
      "\n",
      "Set with the use of String: \n",
      "{'F', 'r', 'o', 's', 'G', 'e', 'k'}\n",
      "\n",
      "Set with the use of List: \n",
      "{'For', 'geeks', 'Geeks'}\n",
      "\n",
      "Set with the use of Mixed Values\n",
      "{'For', 1, 2, 4, 6, 'Geeks'}\n"
     ]
    }
   ],
   "source": [
    "# Python program to demonstrate\n",
    "# Creation of Set in Python\n",
    "\t\n",
    "# Creating a Set\n",
    "set1 = set()\n",
    "print(\"Initial blank Set: \")\n",
    "print(set1)\n",
    "\t\n",
    "# Creating a Set with\n",
    "# the use of a String\n",
    "set1 = set(\"GeeksForGeeks\")\n",
    "print(\"\\nSet with the use of String: \")\n",
    "print(set1)\n",
    "\n",
    "# Creating a Set with\n",
    "# the use of a List\n",
    "set1 = set([\"Geeks\", \"For\", \"geeks\"])\n",
    "print(\"\\nSet with the use of List: \")\n",
    "print(set1)\n",
    "\n",
    "# Creating a Set with\n",
    "# a mixed type of values\n",
    "# (Having numbers and strings)\n",
    "set1 = set([1, 2, 'Geeks', 4, 'For', 6, 'Geeks'])\n",
    "print(\"\\nSet with the use of Mixed Values\")\n",
    "print(set1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a8ab6d7",
   "metadata": {},
   "source": [
    "Accessing elements of Sets\n",
    "\n",
    "Set items cannot be accessed by referring to an index, since sets are unordered the items has no index. But you can loop through the set items using a for loop, or ask if a specified value is present in a set, by using the in keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3c5fbe46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Initial set\n",
      "{'For', 'Geeks'}\n",
      "\n",
      "Elements of set: \n",
      "For Geeks True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Python program to demonstrate\n",
    "# Accessing of elements in a set\n",
    "\t\n",
    "# Creating a set\n",
    "set1 = set([\"Geeks\", \"For\", \"Geeks\"])\n",
    "print(\"\\nInitial set\")\n",
    "print(set1)\n",
    "\t\n",
    "# Accessing element using\n",
    "# for loop\n",
    "print(\"\\nElements of set: \")\n",
    "for i in set1:\n",
    "\tprint(i, end =\" \")\n",
    "\t\n",
    "# Checking the element\n",
    "# using in keyword\n",
    "print(\"Geeks\" in set1)\n",
    "print(\"apple\" in set1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8260c33",
   "metadata": {},
   "source": [
    "# Dictionary datatype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23d2e428",
   "metadata": {},
   "source": [
    "Dictionary in Python is an unordered collection of data values, used to store data values like a map, which unlike other Data Types that hold only single value as an element, Dictionary holds key:value pair. Key-value is provided in the dictionary to make it more optimized. Each key-value pair in a Dictionary is separated by a colon :, whereas each key is separated by a ‘comma’.\n",
    "\n",
    "Creating Dictionary\n",
    "In Python, a Dictionary can be created by placing a sequence of elements within curly {} braces, separated by ‘comma’. Values in a dictionary can be of any datatype and can be duplicated, whereas keys can’t be repeated and must be immutable. Dictionary can also be created by the built-in function dict(). An empty dictionary can be created by just placing it to curly braces{}.\n",
    "\n",
    "Note – Dictionary keys are case sensitive, same name but different cases of Key will be treated distinctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8696ca2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Empty Dictionary: \n",
      "{}\n",
      "\n",
      "Dictionary with the use of Integer Keys: \n",
      "{1: 'Geeks', 2: 'For', 3: 'Geeks'}\n",
      "\n",
      "Dictionary with the use of Mixed Keys: \n",
      "{'Name': 'Geeks', 1: [1, 2, 3, 4]}\n",
      "\n",
      "Dictionary with the use of dict(): \n",
      "{1: 'Geeks', 2: 'For', 3: 'Geeks'}\n",
      "\n",
      "Dictionary with each item as a pair: \n",
      "{1: 'Geeks', 2: 'For'}\n"
     ]
    }
   ],
   "source": [
    "# Creating an empty Dictionary\n",
    "Dict = {}\n",
    "print(\"Empty Dictionary: \")\n",
    "print(Dict)\n",
    "\t\n",
    "# Creating a Dictionary\n",
    "# with Integer Keys\n",
    "Dict = {1: 'Geeks', 2: 'For', 3: 'Geeks'}\n",
    "print(\"\\nDictionary with the use of Integer Keys: \")\n",
    "print(Dict)\n",
    "\t\n",
    "# Creating a Dictionary\n",
    "# with Mixed keys\n",
    "Dict = {'Name': 'Geeks', 1: [1, 2, 3, 4]}\n",
    "print(\"\\nDictionary with the use of Mixed Keys: \")\n",
    "print(Dict)\n",
    "\n",
    "student = {'roll_no': 12, 'name': 'xyz', 'subjects': ['s1', 's2'], 'marks': [18, 20]}\n",
    "\t\n",
    "# Creating a Dictionary\n",
    "# with dict() method\n",
    "Dict = dict({1: 'Geeks', 2: 'For', 3:'Geeks'})\n",
    "print(\"\\nDictionary with the use of dict(): \")\n",
    "print(Dict)\n",
    "\t\n",
    "# Creating a Dictionary\n",
    "# with each item as a Pair\n",
    "Dict = dict([(1, 'Geeks'), (2, 'For')])\n",
    "print(\"\\nDictionary with each item as a pair: \")\n",
    "print(Dict)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7202c3f9",
   "metadata": {},
   "source": [
    "Accessing elements of Dictionary\n",
    "\n",
    "In order to access the items of a dictionary refer to its key name. Key can be used inside square brackets. There is also a method called get() that will also help in accessing the element from a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2d55b0f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accessing a element using key:\n",
      "For\n",
      "Geeks\n",
      "Accessing a element using get:\n",
      "Lemons\n"
     ]
    }
   ],
   "source": [
    "# Python program to demonstrate\n",
    "# accessing a element from a Dictionary\n",
    "\t\n",
    "# Creating a Dictionary\n",
    "Dict = {1: 'Geeks', 'name': 'For', 3: 'Lemons'}\n",
    "\t\n",
    "# accessing a element using key\n",
    "print(\"Accessing a element using key:\")\n",
    "print(Dict['name'])\n",
    "print(Dict[1])\n",
    "\n",
    "# accessing a element using get()\n",
    "# method\n",
    "print(\"Accessing a element using get:\")\n",
    "print(Dict.get(3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "161d9a4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "Dict = {1: 'Geeks', 'name': 'For', 3: 'Lemons'}\n",
    "# print(Dict['fruits'])\n",
    "\n",
    "print(Dict.get('fruits'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93c1f9bd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}