Python's Built-in Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "512e4e1c",
   "metadata": {},
   "source": [
    "# Python’s Built-In Classes\n",
    "\n",
    "Table below provides a summary of commonly used, built-in classes in Python; we take particular note of which classes are mutable and which are immutable. A class is immutable if each object of that class has a fixed value upon instantiation that cannot subsequently be changed. For example, the float class is immutable. Once an instance has been created, its value cannot be changed (although an identifier referencing that object can be reassigned to a different value).\n",
    "\n",
    "\n",
    "|   class   |              Description               | immutable? |\n",
    "|:---------:|:--------------------------------------:|:----------:|\n",
    "|    bool   |             Boolean value              |     Yes    |\n",
    "|    int    |     integer (arbitrary magnitude)      |     Yes    |\n",
    "|    float  |          floating-point number         |     Yes    |\n",
    "|    list   |      mutable sequence of objects       |      No    |\n",
    "|    tuple  |     immutable sequence of objects      |     Yes    |\n",
    "|    str    |            character string            |     Yes    |\n",
    "|    set    |   unordered set of distinct objects    |      No    |\n",
    "| frozenset |      immutable form of set class       |     Yes    |\n",
    "|    dict   |  associative mapping (aka dictionary)  |      No    |\n",
    "\n",
    "\n",
    "***\n",
    "# bool class\n",
    "***\n",
    "\n",
    "The bool class is used to manipulate logical (Boolean) values, and the only two instances of that class are expressed as the literals True and False. The default constructor, bool(), returns False, but there is no reason to use that syntax rather than the more direct literal form. Python allows the creation of a Boolean value from a nonboolean type using the syntax bool(foo) for value foo. The interpretation depends upon the type of the parameter. Numbers evaluate to False if zero, and\n",
    "True if nonzero. Sequences and other container types, such as strings and lists, evaluate to False if empty and True if nonempty. An important application of this interpretation is the use of a nonboolean value as a condition in a control structure.\n",
    "The Python Boolean type has only two possible values:\n",
    "\n",
    "1. True\n",
    "2. False\n",
    "\n",
    "No other value will have bool as its type. You can check the type of ```True``` and ```False``` with the built-in ```type()```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e44bea2e",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(False))\n",
    "print(type(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "319a3490",
   "metadata": {},
   "source": [
    "* ## Python Booleans as Numbers\n",
    "Booleans are considered a numeric type in Python. This means they’re numbers for all intents and purposes. In other words, you can apply arithmetic operations to Booleans, and you can also compare them to numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9d3ca42e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(True == 1)\n",
    "print(False == 0)\n",
    "print(True + (False / True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb6a6dba",
   "metadata": {},
   "source": [
    "There aren’t many uses for the numerical nature of Boolean values, but there’s one technique you may find helpful. Because True is equal to 1 and False is equal to 0, adding Booleans together is a quick way to count the number of True values. This can come in handy when you need to count the number of items that satisfy a condition.\n",
    "\n",
    "For example, if you want to analyze a verse in a classic children’s poem to see what fraction of lines contain the word \"the\", then the fact that ```True``` is equal to 1 and ```False``` is equal to 0 can come in quite handy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0aa59190",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n"
     ]
    }
   ],
   "source": [
    "lines=\"\"\"He took his vorpal sword in hand;\n",
    "          Long time the manxome foe he sought— \n",
    "          So rested he by the Tumtum tree \n",
    "          And stood awhile in thought.\"\"\".splitlines()\n",
    "\n",
    "print(sum(\"the\" in line.lower() for line in lines) / len(lines))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "976b5e83",
   "metadata": {},
   "source": [
    "* ## Boolean Operators\n",
    "\n",
    "* Since Python Boolean values have only two possible options, ```True``` or ```False```, it’s possible to specify the operators completely in terms of the results they assign to every possible input combination. These specifications are called truth tables since they’re displayed in a table.\n",
    "\n",
    "* ### Boolean logical operators are:\n",
    "1. ```not```\n",
    "2. ```and```\n",
    "3. ```or```\n",
    "\n",
    "* *```not``` operator  truth table*\n",
    "\n",
    "\n",
    "|   A   | not A |\n",
    "|:-----:|:-----:|\n",
    "| True  | False |\n",
    "| False | True  |\n",
    "\n",
    "\n",
    "* *```and``` operator truth table* \n",
    "\n",
    "\n",
    "|   A   |   B   | A and B |\n",
    "|:-----:|:-----:|:-------:|\n",
    "| True  | True  |  True   |\n",
    "| True  | False |  False  |\n",
    "| False | True  |  False  |\n",
    "| False | False |  False  |\n",
    "\n",
    "\n",
    "* *```or``` operator truth table* \n",
    "\n",
    "\n",
    "|   A   |   B   |  A or B |\n",
    "|:-----:|:-----:|:-------:|\n",
    "| True  | True  |  True   |\n",
    "| True  | False |  True   |\n",
    "| False | True  |  True   |\n",
    "| False | False |  False  |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2b9fb1d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not operator:  False\n",
      "and operator:  False\n",
      "or operator:  True\n"
     ]
    }
   ],
   "source": [
    "a = True\n",
    "b = False\n",
    "print(\"not operator: \", not a)\n",
    "print(\"and operator: \", a and b)\n",
    "print(\"or operator: \", a or b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd0e3b62",
   "metadata": {},
   "source": [
    "* ### Boolean equality operators are:\n",
    "1. ```is``` (same identity)\n",
    "2. ```is not``` (different identity)\n",
    "3. ```==``` (equivalent)\n",
    "4. ```!=``` (not equivalent)\n",
    "\n",
    "The expression a is b evaluates to True, precisely when identifiers a and b are aliases for the same object. The expression a == b tests a more general notion of equivalence. If identifiers a and b refer to the same object, then a == b should also\n",
    "evaluate to True. Yet a == b also evaluates to True when the identifiers refer to different objects that happen to have values that are deemed equivalent. The precise notion of equivalence depends on the data type. For example, two strings are considered equivalent if they match character for character. Two sets are equivalent if they have the same contents, irrespective of order. In most programming situations, the equivalence tests == and != are the appropriate operators; use of is and is not should be reserved for situations in which it is necessary to detect true aliasing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6fabd9fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "equality:  True\n",
      "identity:  False\n",
      "identity:  True\n"
     ]
    }
   ],
   "source": [
    "a = 400\n",
    "b = 400\n",
    "c = a\n",
    "print(\"equality: \", a == b)\n",
    "print(\"identity: \", a is b)\n",
    "print(\"identity: \", a is c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c717620",
   "metadata": {},
   "source": [
    "* ### Boolean comparison operators\n",
    "1. ```<``` less than\n",
    "2. ```<=``` less than or equal to\n",
    "3. ```>``` greater than\n",
    "4. ```>=``` greater than or equal to\n",
    "\n",
    "These operators have expected behavior for numeric types, and are defined lexicographically, and case-sensitively, for strings. An exception is raised if operands have incomparable types, as with 5 < \"hello\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "39ff22ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numeric order:  True\n",
      "lexicographic order:  False\n"
     ]
    }
   ],
   "source": [
    "a = 100\n",
    "b = -100\n",
    "c = \"apple\"\n",
    "d = \"orange\"\n",
    "print(\"numeric order: \", a > b)\n",
    "print(\"lexicographic order: \", c > d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d12f57b",
   "metadata": {},
   "source": [
    "* ### The ```is``` Operator\n",
    "\n",
    "The ```is``` operator checks for object identity. In other words, ```x is y``` evaluates to ```True``` only when x and y evaluate to the same object. The ```is``` operator has an opposite, the ```is not``` operator.\n",
    "\n",
    "A typical usage of is and is not is to compare lists for identity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7cfe5e2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = []\n",
    "y = []\n",
    "print(x is x)\n",
    "print(x is y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5d8ab09",
   "metadata": {},
   "source": [
    "* ### The ```in``` Operator\n",
    "\n",
    "The ```in``` operator checks for **membership**. An object can define what it considers members. Most sequences, such as lists, consider their elements to be members:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3eaab4e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "small_even = [2, 4, 6, 8]\n",
    "print(1 in small_even)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1b0e32e",
   "metadata": {},
   "source": [
    "***\n",
    "# float & int class\n",
    "***\n",
    "\n",
    "* ## int class\n",
    "\n",
    "The int and float classes are the primary numeric types in Python. The int class is designed to represent integer values with arbitrary magnitude. Unlike Java and C++, which support different integral types with different precisions (e.g., int, short, long), Python automatically chooses the internal representation for an integer based upon the magnitude of its value.\n",
    "\n",
    "In some contexts, it is convenient to express an integral value using binary, octal, or hexadecimal. That can be done by using a prefix of the number 0 and then a character to describe the base. Example of such literals are respectively ```0b1011```, ```0o52```, and ```0x7f```.\n",
    "\n",
    "we can use ```bin()```, ```oct()``` and ```hex()``` to convert a decimal number to these literals and we can also use ```int()``` to convert from those literals to decimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "081178c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "decimal:  25\n",
      "binary:  0b11001\n",
      "octal:  0o31\n",
      "hexadecimal:  0x19\n",
      "hexadecimal converted to decimal:  25\n"
     ]
    }
   ],
   "source": [
    "decimal = 25\n",
    "binary = bin(decimal)\n",
    "octal = oct(decimal)\n",
    "hexadecimal = hex(decimal)\n",
    "print(\"decimal: \", decimal)\n",
    "print(\"binary: \", binary)\n",
    "print(\"octal: \", octal)\n",
    "print(\"hexadecimal: \", hexadecimal)\n",
    "converted_hex = int(\"0x19\", 16)  # Note that the value passed to int() is of string type.\n",
    "print(\"hexadecimal converted to decimal: \", converted_hex)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1091f0d8",
   "metadata": {},
   "source": [
    "* ## float class\n",
    "\n",
    "The float class is the sole floating-point type in Python, using a fixed-precision representation. Its precision is more akin to a double in Java or C++, rather than those languages’ float type. We have already discussed a typical literal form, ```98.6```.\n",
    "We note that the floating-point equivalent of an integral number can be expressed directly as ```2.0```. Technically, the trailing zero is optional, so some programmers might use the expression ```2```. to designate this floating-point literal. One other form\n",
    "of literal for floating-point values uses scientific notation. For example, the literal ```6.022e23``` represents the mathematical value ```6.022×10^23```."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3972288",
   "metadata": {},
   "source": [
    "* ### int & float Arithmetic Operators\n",
    "\n",
    "1. ```+``` addition\n",
    "2. ```−``` subtraction\n",
    "3. ```*``` multiplication\n",
    "4. ```/``` true division\n",
    "5. ```//``` integer division\n",
    "6. ```%``` the modulo operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "82cd59f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "addition:  8\n",
      "subtraction:  7\n",
      "multiplication:  54\n",
      "true division:  2.3333333333333335\n",
      "integer division:  1\n",
      "the modulo operator:  4\n"
     ]
    }
   ],
   "source": [
    "print(\"addition: \", 3 + 5)\n",
    "print(\"subtraction: \", 11 - 4)\n",
    "print(\"multiplication: \", 9 * 6)\n",
    "print(\"true division: \", 7 / 3)\n",
    "print(\"integer division: \", 17 // 13)\n",
    "print(\"the modulo operator: \", 24 % 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19a8a616",
   "metadata": {},
   "source": [
    "* ### Math Functions and Number Methods\n",
    "1. ```round()```, for rounding numbers to some number of decimal places\n",
    "2. ```abs()```, for getting the absolute value of a number\n",
    "3. ```pow()```, for raising a number to some power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "10f0cdc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "round:  3.1416\n",
      "abs:  12.5\n",
      "pow:  16\n"
     ]
    }
   ],
   "source": [
    "print(\"round: \", round(3.141596, 4))\n",
    "print(\"abs: \", abs(-12.5))\n",
    "print(\"pow: \", pow(2, 4))  # same as 2 ** 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31dc11ab",
   "metadata": {},
   "source": [
    "* ### *some subtle errors*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "de67e2d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.30000000000000004\n"
     ]
    }
   ],
   "source": [
    "print(0.1 + 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dfaec8b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "from fractions import Fraction \n",
    "a = 0\n",
    "for i in range(10):\n",
    "    a = a + Fraction(1, 10) # a += 0.1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad0b7d8",
   "metadata": {},
   "source": [
    "It’s a floating-point representation error, and it has nothing to do with Python. It’s related to the way floating-point numbers are stored in a computer’s memory.\n",
    "\n",
    "The number ```0.1``` can be represented as the fraction ```1/10```. Both the number 0.1 and its fraction 1/10 are decimal representations, or base-10 representations. Computers, however, store floating-point numbers in base-2 representation, more commonly called binary representation.\n",
    "\n",
    "When represented in binary, something familiar yet possibly unexpected happens to the decimal number ```0.1```. The fraction ```1/3``` has no finite decimal representation. That is, ```1/3 = 0.3333...``` with infinitely many 3s after the decimal point. The same thing happens to the fraction ```1/10``` in binary.\n",
    "\n",
    "The binary representation of ```1/10``` is the following infinitely repeating fraction:\n",
    "```0.00011001100110011001100110011...```\n",
    "\n",
    "Computers have finite memory, so the number ```0.1``` must be stored as an approximation and not as its true value. The approximation that gets stored is slightly higher than the actual value and looks like this:\n",
    "```0.1000000000000000055511151231257827021181583404541015625```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e959ea4d",
   "metadata": {},
   "source": [
    "***\n",
    "# list class\n",
    "***\n",
    "\n",
    "A list instance stores a sequence of objects. A list is a referential structure, as it technically stores a sequence of references to its elements. Elements of a list may be arbitrary objects (including the None object). Lists are array-based sequences and are zero-indexed, thus a list of length n has elements indexed from 0 to n−1 inclusive.\n",
    "\n",
    "Lists are perhaps the most used container type in Python and they will be extremely central to our study of data structures and algorithms. They have many valuable behaviors, including the ability to dynamically expand and contract their capacities as needed.\n",
    "\n",
    "Python uses the characters ```[]``` as delimiters for a list literal, with ```[]``` itself being an empty list. As another example, ```[red, green, blue ]``` is a list containing three string instances. The contents of a list literal need not be expressed as literals; if identifiers ```a``` and ```b``` have been established, then syntax ```[a, b]``` is legitimate.\n",
    "\n",
    "The important characteristics of Python lists are as follows:\n",
    "\n",
    "* Lists are ordered.\n",
    "* Lists can contain any arbitrary objects.\n",
    "* List elements can be accessed by index.\n",
    "* Lists can be nested to arbitrary depth.\n",
    "* Lists are mutable.\n",
    "* Lists are dynamic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c3546914",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prime:  [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]\n",
      "c:  ['hello', 'world']\n",
      "nested list:  [[1, 2], [3, 4]]\n"
     ]
    }
   ],
   "source": [
    "prime = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]\n",
    "a = \"hello\"\n",
    "b = \"world\"\n",
    "c = [a, b]\n",
    "print(\"prime: \", prime)\n",
    "print(\"c: \", c)\n",
    "nested = [[1, 2], [3, 4]]\n",
    "print(\"nested list: \", nested)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d67ed9ee",
   "metadata": {},
   "source": [
    "* ## List Operators\n",
    "\n",
    "Several Python operators and built-in functions can also be used with lists in ways that are analogous to strings(we will discuss later):"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "564d2d17",
   "metadata": {},
   "source": [
    "* ### The ```in``` and ```not in``` operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "895fdad5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "prime = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]\n",
    "print(1 in prime)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de044bc5",
   "metadata": {},
   "source": [
    "* ### The concatenation ```+``` and replication ```*``` operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ccc82233",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['flower', 'tree', 'mountain', 'lake']\n",
      "['flower', 'tree', 'flower', 'tree', 'flower', 'tree']\n"
     ]
    }
   ],
   "source": [
    "a = [\"flower\", \"tree\"]\n",
    "b = [\"mountain\", \"lake\"]\n",
    "c = a + b\n",
    "print(c)\n",
    "d = a * 3\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "385794b9",
   "metadata": {},
   "source": [
    "* ### The ```len()```, ```min()```, and ```max()``` functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "975244a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of the array is:  6\n",
      "minimum item of the array is:  bar\n",
      "maximum item of the array is:  qux\n"
     ]
    }
   ],
   "source": [
    "a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']\n",
    "print(\"length of the array is: \", len(a))\n",
    "print(\"minimum item of the array is: \", min(a))\n",
    "print(\"maximum item of the array is: \", max(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "491f050c",
   "metadata": {},
   "source": [
    "* ## Indexing and Slicing\n",
    "\n",
    "Individual elements in a list can be accessed using an index in square brackets. This is exactly analogous to accessing individual characters in a string. List indexing is zero-based as it is with strings.\n",
    "\n",
    "* **Indexing**\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.c11ea56e8ca2.png\" width=\"430\"/>\n",
    "</div>\n",
    "\n",
    "* **Slicing**\n",
    "\n",
    "<div>\n",
    "<img src=\"https://media.geeksforgeeks.org/wp-content/uploads/20201025141338/Screenshot584.png\" width=\"430\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "522fbdfb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "second element:  orange\n",
      "first to third elements:  ['orange', 'cookie']\n",
      "till second element:  ['apple', 'orange']\n",
      "from third element:  ['coffee', 'bread']\n"
     ]
    }
   ],
   "source": [
    "example = [\"apple\", \"orange\", \"cookie\", \"coffee\", \"bread\"]\n",
    "print(\"second element: \", example[1])\n",
    "print(\"first to third elements: \", example[1:3])\n",
    "print(\"till second element: \", example[:2])\n",
    "print(\"from third element: \", example[3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19965412",
   "metadata": {},
   "source": [
    "* ## List Methods\n",
    "1. ```append()``` :\tAdds an element at the end of the list\n",
    "2. ```clear()``` : Removes all the elements from the list\n",
    "3. ```copy()``` : Returns a copy of the list\n",
    "4. ```count()``` : Returns the number of elements with the specified value\n",
    "5. ```extend()``` :\tAdd the elements of a list (or any iterable), to the end of the current list\n",
    "6. ```index()``` : Returns the index of the first element with the specified value\n",
    "7. ```insert()``` :\tAdds an element at the specified position\n",
    "8. ```pop()``` : Removes the element at the specified position\n",
    "9. ```remove()``` :\tRemoves the first item with the specified value\n",
    "10. ```reverse()``` : Reverses the order of the list\n",
    "11. ```sort()``` : Sorts the list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c02286b",
   "metadata": {},
   "source": [
    "* **```append()```**\n",
    "\n",
    "The ```append()``` method appends an element to the end of the list.\n",
    "\n",
    "*   **syntax:** list.append(element)\n",
    "\n",
    "    element(Required): An element of any type (string, number, object etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "24a05683",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before appending:  ['breakfast', 'lunch']\n",
      "after appending b:  ['breakfast', 'lunch', 'dinner']\n",
      "after appending c:  ['breakfast', 'lunch', 'dinner', ['snack']]\n"
     ]
    }
   ],
   "source": [
    "a = [\"breakfast\", \"lunch\"]\n",
    "b = \"dinner\"\n",
    "c = [\"snack\"]\n",
    "print(\"before appending: \", a)\n",
    "a.append(b)\n",
    "print(\"after appending b: \", a)\n",
    "a.append(c)\n",
    "print(\"after appending c: \", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f53b110d",
   "metadata": {},
   "source": [
    "* **```clear()```**\n",
    "\n",
    "The ```clear()``` method removes all the elements from a list.\n",
    "\n",
    "*   **synatx:** list.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3710e70c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before clearing the list:  ['apple', 'banana', 'orange']\n",
      "after clearing the list:  []\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'orange']\n",
    "print(\"before clearing the list: \", fruits)\n",
    "fruits.clear()\n",
    "print(\"after clearing the list: \", fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcd1734d",
   "metadata": {},
   "source": [
    "* **```copy()```**\n",
    "\n",
    "The ```copy()``` method returns a copy of the specified list.\n",
    "\n",
    "* **syntax:** list.copy()\n",
    "\n",
    "copying a list is useful when we are linking references because doing this may cause some unwanted errors, take look at the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3dbd35b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before modifying lists: \n",
      "a:  [1, 2, 3]\n",
      "b:  [1, 2, 3]\n",
      "\n",
      "after modifying lists: \n",
      "a:  [1, 'python', 3]\n",
      "b:  [1, 'python', 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "print(\"before modifying lists: \")\n",
    "print(\"a: \", a)\n",
    "print(\"b: \", b)\n",
    "a[1] = \"python\"\n",
    "print(\"\\nafter modifying lists: \")\n",
    "print(\"a: \", a)\n",
    "print(\"b: \", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e86591a2",
   "metadata": {},
   "source": [
    "as it is illustrated by the above example, changing one of the variables will result in a change in another one.in order to avoid this kind of problem, we use the ```copy()``` method to make a copy of the original one to freely change whatever we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ca2a2c36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before modifying lists: \n",
      "a:  [1, 2, 3]\n",
      "b:  [1, 2, 3]\n",
      "\n",
      "after modifying lists: \n",
      "a:  [1, 'python', 3]\n",
      "b:  [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a.copy()\n",
    "print(\"before modifying lists: \")\n",
    "print(\"a: \", a)\n",
    "print(\"b: \", b)\n",
    "a[1] = \"python\"\n",
    "print(\"\\nafter modifying lists: \")\n",
    "print(\"a: \", a)\n",
    "print(\"b: \", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06627467",
   "metadata": {},
   "source": [
    "* **```count()```**\n",
    "\n",
    "The ```count()``` method returns the number of elements with the specified value.\n",
    "\n",
    "*   **syntax:** list.count(value)\n",
    "\n",
    "    value(Required): Any type (string, number, list, tuple, etc.). The value to search for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d5a7be10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count of milk: 2\n",
      "count of ice cream: 1\n"
     ]
    }
   ],
   "source": [
    "dairy = [\"milk\", \"butter\", \"cheese\", \"yoghurt\", \"milk\", \"ice cream\"]\n",
    "print(\"count of milk:\", dairy.count(\"milk\"))\n",
    "print(\"count of ice cream:\", dairy.count(\"ice cream\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d62a5ffb",
   "metadata": {},
   "source": [
    "* **```extend()```**\n",
    "\n",
    "The ```extend()``` method adds the specified list elements (or any iterable) to the end of the current list.\n",
    "\n",
    "*   **syntax:** list.extend(iterable)\n",
    "\n",
    "    iterable(Required): Any iterable (list, set, tuple, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "7069f7ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extended list:  None\n",
      "but phone manufacturers is extended:  ['apple', 'samsung', 'google', 'xiaomi', 'apple', 'asus', 'msi', 'microsoft']\n"
     ]
    }
   ],
   "source": [
    "phone_manufacturers = [\"apple\", \"samsung\", \"google\", \"xiaomi\"]\n",
    "laptop_manufacturers = [\"apple\", \"asus\", \"msi\", \"microsoft\"]\n",
    "extended_list = phone_manufacturers.extend(laptop_manufacturers)\n",
    "print(\"extended list: \", extended_list)  # surprisingly returns None type! what happens?!\n",
    "print(\"but phone manufacturers is extended: \", phone_manufacturers)  # why?!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da52bc05",
   "metadata": {},
   "source": [
    "*in order to create a variable to save the extended list in it, you can use the following code:*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f12d58e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extended list:  ['apple', 'samsung', 'google', 'xiaomi', 'apple', 'asus', 'msi', 'microsoft']\n"
     ]
    }
   ],
   "source": [
    "phone_manufacturers = [\"apple\", \"samsung\", \"google\", \"xiaomi\"]\n",
    "laptop_manufacturers = [\"apple\", \"asus\", \"msi\", \"microsoft\"]\n",
    "extended_list = phone_manufacturers + laptop_manufacturers\n",
    "print(\"extended list: \", extended_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d337458b",
   "metadata": {},
   "source": [
    "* **```index()```**\n",
    "\n",
    "The ```index()``` method returns the position at the first occurrence of the specified value.\n",
    "\n",
    "*   **syntax:** list.index(element)\n",
    "\n",
    "    element(Required): Any type (string, number, list, etc.). The element to s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "bd5dfe22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cherry's index is:  2\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"orange\"]\n",
    "index = fruits.index(\"cherry\")\n",
    "print(\"cherry's index is: \", index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc2a521d",
   "metadata": {},
   "source": [
    "* **```insert()```**\n",
    "\n",
    "The ```insert()``` method inserts the specified value at the specified position.\n",
    "\n",
    "* **syntax:** list.insert(position_index, element)\n",
    "\n",
    "    position_index(Required): A number specifying in which position to insert the value\n",
    "    \n",
    "    element(Required): An element of any type (string, number, object etc.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c3273742",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new list:  ['apple', 'banana', 'strawberry', 'cherry', 'orange']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"orange\"]\n",
    "fruits.insert(2, \"strawberry\")\n",
    "print(\"new list: \", fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49c01183",
   "metadata": {},
   "source": [
    "* **```pop()```**\n",
    "\n",
    "The ```pop()``` method removes the element at the specified position.\n",
    "\n",
    "*   **syntax:** list.pop(position_index)\n",
    "\n",
    "    position_index(Optional): A number specifying the position of the element you want to remove, default value is -1, which returns the last item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "99b0a078",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new list:  ['apple', 'cherry', 'orange']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"orange\"]\n",
    "fruits.pop(1)\n",
    "print(\"new list: \", fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c13aae6e",
   "metadata": {},
   "source": [
    "* <mark> Note: The ```pop()``` method returns removed value. </mark>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f6fcdab9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new list:  ['apple', 'cherry', 'orange']\n",
      "popped item:  banana\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"orange\"]\n",
    "item = fruits.pop(1)\n",
    "print(\"new list: \", fruits)\n",
    "print(\"popped item: \", item)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fc620b4",
   "metadata": {},
   "source": [
    "* **```remove()```**\n",
    "\n",
    "The ```remove()``` method removes the first occurrence of the element with the specified value.\n",
    "\n",
    "*   **syntax:** list.remove(element)\n",
    "\n",
    "    element(Required): Any type (string, number, list etc.) The element you want to remove"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "fe952013",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "given list after removing an item:  ['bmw', 'volvo', 'ford']\n"
     ]
    }
   ],
   "source": [
    "cars = [\"bmw\", \"mercedes\", \"volvo\", \"ford\"]\n",
    "cars.remove(\"mercedes\")\n",
    "print(\"given list after removing an item: \", cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faa6c31f",
   "metadata": {},
   "source": [
    "* **```reverse()```**\n",
    "\n",
    "The ```reverse()``` method reverses the sorting order of the elements.\n",
    "\n",
    "*   **syntax:** list.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "4a2b7ff2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reversed list:  ['ford', 'volvo', 'mercedes', 'bmw']\n"
     ]
    }
   ],
   "source": [
    "cars = [\"bmw\", \"mercedes\", \"volvo\", \"ford\"]\n",
    "cars.reverse()\n",
    "print(\"reversed list: \", cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b31e47dc",
   "metadata": {},
   "source": [
    "* <mark> Note: there is also a built-in function in python named ```reversed()```. the difference between ```reversed()``` function and list's ```reverse()``` method is that the first one just returns the reversed iterable and applies no change to the iterable, but the second one does not return anything at all, but it makes the changes directly to the object. for further illustration look at the following code: <mark>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e8e1e27a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reversed cars list:  None\n"
     ]
    }
   ],
   "source": [
    "cars = [\"bmw\", \"mercedes\", \"volvo\", \"ford\"]\n",
    "reversed_cars = cars.reverse()\n",
    "print(\"reversed cars list: \", reversed_cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4182b56a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reversed cars list:  ['ford', 'volvo', 'mercedes', 'bmw']\n",
      "['bmw', 'mercedes', 'volvo', 'ford']\n"
     ]
    }
   ],
   "source": [
    "cars = [\"bmw\", \"mercedes\", \"volvo\", \"ford\"]\n",
    "reversed_cars = reversed(cars)\n",
    "print(\"reversed cars list: \", list(reversed_cars))  # we can unpack this object by a single list() syntax.\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e7834b4",
   "metadata": {},
   "source": [
    "* **```sort()```**: \n",
    "\n",
    "The ```sort()``` method sorts the list ascending by default.\n",
    "\n",
    "You can also make a function to decide the sorting criteria(s).\n",
    "\n",
    "*   **syntax**: list.sort(reverse=True|False, key=myFunc)\n",
    "\n",
    "    reverse(Optional): reverse=True will sort the list descending. Default is reverse=False.\n",
    "    \n",
    "    key(Optional): A function to specify the sorting criteria(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9a22bc2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reverse sorted list:  ['volvo', 'ford', 'bmw']\n",
      "sorted list:  ['bmw', 'ford', 'volvo']\n"
     ]
    }
   ],
   "source": [
    "cars = [\"ford\", \"bmw\", \"volvo\"]\n",
    "cars.sort(reverse=True)\n",
    "print(\"reverse sorted list: \", cars)\n",
    "cars.sort()\n",
    "print(\"sorted list: \", cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "acf00609",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sorted list:  ['bmw', 'ford', 'volvo']\n"
     ]
    }
   ],
   "source": [
    "def function(iterable):\n",
    "   return len(iterable)\n",
    "\n",
    "cars = [\"ford\", \"bmw\", \"volvo\"]\n",
    "cars.sort(key=function)\n",
    "print(\"sorted list: \", cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb3cc3a4",
   "metadata": {},
   "source": [
    "* <mark> Note: just like above, there is also a built-in function in python named ```sorted()```. the difference between ```sorted()``` function and list's ```sort()``` method is that the first one just returns the sorted iterable and applies no change to the iterable, but the second one does not return anything at all, but it makes the changes directly to the object. for further illustration look at the following code: <mark>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "feb433e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sorted cars list:  None\n"
     ]
    }
   ],
   "source": [
    "cars = [\"bmw\", \"mercedes\", \"volvo\", \"ford\"]\n",
    "sorted_cars = cars.sort()\n",
    "print(\"sorted cars list: \", sorted_cars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "507d0182",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sorted cars list:  ['bmw', 'ford', 'mercedes', 'volvo']\n"
     ]
    }
   ],
   "source": [
    "cars = [\"bmw\", \"mercedes\", \"volvo\", \"ford\"]\n",
    "sorted_cars = sorted(cars)\n",
    "print(\"sorted cars list: \", sorted_cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8762553e",
   "metadata": {},
   "source": [
    "***\n",
    "# Tuple Class\n",
    "***\n",
    "\n",
    "The tuple class provides an immutable version of a sequence, and therefore its instances have an internal representation that may be more streamlined than that of a list. While Python uses the ```[]``` characters to delimit a list, parentheses delimit a\n",
    "tuple, with ```()``` being an empty tuple. There is one important subtlety. To express a tuple of length one as a literal, a comma must be placed after the element, but within the parentheses. For example, ```(17,)``` is a one-element tuple. The reason for this requirement is that, without the trailing comma, the expression ```(17)``` is viewed as a simple parenthesized numeric expression.\n",
    "\n",
    "\n",
    "The important characteristics of Python tuples are as follows:\n",
    "\n",
    "* tuples are ordered.\n",
    "* tuples can contain any arbitrary objects.\n",
    "* tuples elements can be accessed by index.\n",
    "* tuples can be nested to arbitrary depth.\n",
    "* tuples are immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1f88330d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cars:  ('bmw', 'mercedes', 'volvo', 'ford')\n",
      "c:  ('hello', 'world')\n",
      "nested tuples:  ((1, 2), (3, 4))\n"
     ]
    }
   ],
   "source": [
    "cars = (\"bmw\", \"mercedes\", \"volvo\", \"ford\")\n",
    "a = \"hello\"\n",
    "b = \"world\"\n",
    "c = (a, b)\n",
    "print(\"cars: \", cars)\n",
    "print(\"c: \", c)\n",
    "nested = ((1, 2), (3, 4))\n",
    "print(\"nested tuples: \", nested)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82345b91",
   "metadata": {},
   "source": [
    "* ## Tuple Operators\n",
    "\n",
    "Several Python operators and built-in functions can also be used with tuples:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d175284",
   "metadata": {},
   "source": [
    "* ### The ```in``` and ```not in``` operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "29f23258",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "prime = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)\n",
    "print(1 in prime)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b00e4ec",
   "metadata": {},
   "source": [
    "* ### The concatenation ```+``` and replication ```*``` operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "849d91dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('flower', 'tree', 'mountain', 'lake')\n",
      "('flower', 'tree', 'flower', 'tree', 'flower', 'tree')\n"
     ]
    }
   ],
   "source": [
    "a = (\"flower\", \"tree\")\n",
    "b = (\"mountain\", \"lake\")\n",
    "c = a + b\n",
    "print(c)\n",
    "d = a * 3\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faf44914",
   "metadata": {},
   "source": [
    "* ### The ```len()```, ```min()```, and ```max()``` functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b9038afa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of the array is:  6\n",
      "minimum item of the array is:  bar\n",
      "maximum item of the array is:  qux\n"
     ]
    }
   ],
   "source": [
    "a = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')\n",
    "print(\"length of the array is: \", len(a))\n",
    "print(\"minimum item of the array is: \", min(a))\n",
    "print(\"maximum item of the array is: \", max(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "695893cc",
   "metadata": {},
   "source": [
    "* ## Indexing and Slicing\n",
    "\n",
    "Individual elements in a tuple can be accessed using an index in square brackets. This is exactly analogous to accessing individual characters in a list. tuple indexing is zero-based as it is with lists.\n",
    "\n",
    "* ### Indexing\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.c11ea56e8ca2.png\" width=\"430\"/>\n",
    "</div>\n",
    "\n",
    "* ### Slicing\n",
    "\n",
    "<div>\n",
    "<img src=\"https://media.geeksforgeeks.org/wp-content/uploads/20201025141338/Screenshot584.png\" width=\"430\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "4b5b4738",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "second element:  orange\n",
      "first to third elements:  ('orange', 'cookie')\n",
      "till second element:  ('apple', 'orange')\n",
      "from third element:  ('coffee', 'bread')\n"
     ]
    }
   ],
   "source": [
    "example = (\"apple\", \"orange\", \"cookie\", \"coffee\", \"bread\")\n",
    "print(\"second element: \", example[1])\n",
    "print(\"first to third elements: \", example[1:3])\n",
    "print(\"till second element: \", example[:2])\n",
    "print(\"from third element: \", example[3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1e87309",
   "metadata": {},
   "source": [
    "* ## Changing Tuple Values\n",
    "\n",
    "Once a tuple is created, you cannot change its values. Tuples are unchangeable, or immutable as it also is called.\n",
    "\n",
    "But there is a workaround. You can convert the tuple into a list, change the list, and convert the list back into a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "4746cba5",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial tuple:  ('pen', 'pencil', 'eraser', 'marker')\n",
      "modified tuple:  ('pen', 'correction pen', 'eraser', 'marker')\n"
     ]
    }
   ],
   "source": [
    "stationeries = (\"pen\", \"pencil\", \"eraser\", \"marker\")\n",
    "print(\"initial tuple: \", stationeries)\n",
    "list_of_stationeries = list(stationeries)\n",
    "list_of_stationeries[1] = \"correction pen\"\n",
    "stationeries = tuple(list_of_stationeries)\n",
    "print(\"modified tuple: \", stationeries)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58e13ed4",
   "metadata": {},
   "source": [
    "* ## Add Items\n",
    "\n",
    "Since tuples are immutable, they do not have a build-in ```append()``` method, but there are other ways to add items to a tuple.\n",
    "\n",
    "1. **Convert into a list:** Just like the workaround for changing a tuple, you can convert it into a list, add your item(s), and convert it back into a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "21dc5614",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial tuple:  ('apple', 'banana', 'cherry')\n",
      "modified tuple:  ('apple', 'banana', 'cherry', 'orange')\n"
     ]
    }
   ],
   "source": [
    "fruits_tuple = (\"apple\", \"banana\", \"cherry\")\n",
    "print(\"initial tuple: \", fruits_tuple)\n",
    "list_of_fruits = list(fruits_tuple)\n",
    "list_of_fruits.append(\"orange\")\n",
    "fruits_tuple = tuple(list_of_fruits)\n",
    "print(\"modified tuple: \", fruits_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5c01444",
   "metadata": {},
   "source": [
    "2. **Add tuple to a tuple (aka joining tuples):** You are allowed to add tuples to tuples, so if you want to add one item, (or many), create a new tuple with the item(s), and add it to the existing tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7c845e68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial tuple:  ('apple', 'banana', 'cherry')\n",
      "modified tuple:  ('apple', 'banana', 'cherry', 'orange')\n"
     ]
    }
   ],
   "source": [
    "fruits_tuple = (\"apple\", \"banana\", \"cherry\")\n",
    "print(\"initial tuple: \", fruits_tuple)\n",
    "orange = (\"orange\",)\n",
    "fruits_tuple += orange  # we can also write: fruits_tuple = fruits_tuple + orange\n",
    "print(\"modified tuple: \", fruits_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48d2bfbb",
   "metadata": {},
   "source": [
    "* ## packing and unpacking\n",
    "\n",
    "When we create a tuple, we normally assign values to it. This is called \"packing\" a tuple:\n",
    "\n",
    "```python\n",
    "sports = (\"football\", \"basketball\", \"volleyball\", \"tennis\")\n",
    "```\n",
    "\n",
    "When this occurs, it is as though the items in the tuple have been “packed” into the object:\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.feb20d10b75d.png\" width=\"430\"/>\n",
    "</div>\n",
    "\n",
    "If that “packed” object is subsequently assigned to a new tuple, the individual items are “unpacked” into the objects in the tuple:\n",
    "\n",
    "```python\n",
    "first_item, second_item, third_item, fourth_item = (\"football\", \"basketball\", \"volleyball\", \"tennis\")\n",
    "```\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.629d7402a412.png\" width=\"430\"/>\n",
    "</div>\n",
    "\n",
    "<mark> Note: The number of variables must match the number of values in the tuple, if not, you must use an **asterisk** to collect the remaining values as a list. </mark>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "296b095d",
   "metadata": {},
   "source": [
    "* ### Using Asterisk\n",
    "\n",
    "If the number of variables is less than the number of values, you can add an ```*``` to the variable name and the values will be assigned to the variable as a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "80088c7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "green fruit:  apple\n",
      "yellow fruit:  banana\n",
      "red_fruits:  ['cherry', 'strawberry', 'raspberry']\n"
     ]
    }
   ],
   "source": [
    "fruits = (\"apple\", \"banana\", \"cherry\", \"strawberry\", \"raspberry\")\n",
    "\n",
    "(green_fruit, yellow_fruit, *red_fruits) = fruits\n",
    "\n",
    "print(\"green fruit: \", green_fruit)\n",
    "print(\"yellow fruit: \", yellow_fruit)\n",
    "print(\"red_fruits: \", red_fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c217f7e8",
   "metadata": {},
   "source": [
    "**Note:** If the asterisk is added to another variable name than the last, Python will assign values to the variable until the number of values left matches the number of variables left."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "96a45226",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "green fruit:  apple\n",
      "tropical fruits:  ['mango', 'papaya', 'pineapple']\n",
      "red fruit:  cherry\n"
     ]
    }
   ],
   "source": [
    "fruits = (\"apple\", \"mango\", \"papaya\", \"pineapple\", \"cherry\")\n",
    "\n",
    "(green_fruit, *tropical_fruits, red_fruit) = fruits\n",
    "\n",
    "print(\"green fruit: \", green_fruit)\n",
    "print(\"tropical fruits: \", tropical_fruits)\n",
    "print(\"red fruit: \", red_fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce4b6051",
   "metadata": {},
   "source": [
    "* ## tuple Methods\n",
    "1. ```count()``` : Returns the number of elements with the specified value\n",
    "2. ```index()``` : Returns the index of the first element with the specified value"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f138a18",
   "metadata": {},
   "source": [
    "* **```count()```**\n",
    "\n",
    "The ```count()``` method returns the number of elements with the specified value.\n",
    "\n",
    "*   **Syntax:** tuple.count(value)\n",
    "\n",
    "    value(Required): The item to search for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "72626178",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count of five in tuple:  2\n"
     ]
    }
   ],
   "source": [
    "a = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)\n",
    "five_count = a.count(5)\n",
    "print(\"count of five in tuple: \", five_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eed5803d",
   "metadata": {},
   "source": [
    "* **```index()```**\n",
    "\n",
    "The ```index()``` method returns the position at the first occurrence of the specified value.\n",
    "\n",
    "*   **Syntax:** tuple.index(value)\n",
    "\n",
    "    value(Required): The item to search for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d69f5213",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index of 8:  3\n"
     ]
    }
   ],
   "source": [
    "a = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)\n",
    "eight_index = a.index(8)\n",
    "print(\"index of 8: \", eight_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5750c88",
   "metadata": {},
   "source": [
    "***\n",
    "# str class\n",
    "***\n",
    "\n",
    "Python’s str class is specifically designed to efficiently represent an immutable sequence of characters, based upon the Unicode international character set. Strings have a more compact internal representation than the referential lists and tuples, as portrayed below:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a664e455",
   "metadata": {},
   "source": [
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.f398a9e25af0.png\" width=\"300\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70eaa2f0",
   "metadata": {},
   "source": [
    "String literals can be enclosed in single quotes, as in ```'hello'``` , or double quotes, as in ```\"hello\"```. This choice is convenient, especially when using another of the quotation characters as an actual character in the sequence, as in ```\"Don t worry\"```. Alternatively, the quote delimiter can be designated using a backslash as a so-called escape character, as in ```'Don\\'t worry'```. \n",
    "\n",
    "Because the backslash has this purpose, the backslash must itself be escaped to occur as a natural character of the string literal, as in ```'C:\\\\Python\\\\'``` , for a string that would be displayed as ```C:\\Python\\```. Other commonly escaped characters are ```\\n``` for newline and ```\\t``` for tab. Unicode characters can be included, such as ```'20\\u20AC'``` for the string ```20€``` . Python also supports using the delimiter ```''``` or ```\"\"\"``` to begin and end a string literal. The advantage of such triple-quoted strings is that newline characters can be embedded naturally (rather than escaped as ```\\n```). This can greatly improve the readability of long, multiline strings in source code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "0cddfd0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "single line string:  Hello\n",
      "\n",
      "string with escape character:  this \t is \t a \t string \t with \t tab \t escape \t character\n",
      "\n",
      "multiline string:  Lorem ipsum dolor sit amet,\n",
      "               consectetur adipiscing elit,\n",
      "               sed do eiusmod tempor incididunt\n",
      "               ut labore et dolore magna aliqua.\n"
     ]
    }
   ],
   "source": [
    "single_line = \"Hello\"\n",
    "print(\"single line string: \", single_line)\n",
    "print()\n",
    "escape_charachter = \"this \\t is \\t a \\t string \\t with \\t tab \\t escape \\t character\"\n",
    "print(\"string with escape character: \", escape_charachter)\n",
    "print()\n",
    "multiline = \"\"\"Lorem ipsum dolor sit amet,\n",
    "               consectetur adipiscing elit,\n",
    "               sed do eiusmod tempor incididunt\n",
    "               ut labore et dolore magna aliqua.\"\"\"  # hidden \\n character\n",
    "print(\"multiline string: \", multiline)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "056c8cb2",
   "metadata": {},
   "source": [
    "* ## Strings operators\n",
    "\n",
    "You have already seen the operators ```+``` and ```*``` applied to numeric operands in the tutorial on Operators and Expressions in Python. These two operators can be applied to strings as well.\n",
    "\n",
    "* **The ```+``` Operator (aka string concatenation)**\n",
    "\n",
    "The ```+``` operator concatenates strings. It returns a string consisting of the operands joined together, as shown here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "57fdc3a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python is cool.\n"
     ]
    }
   ],
   "source": [
    "string_1 = \"python\"\n",
    "string_2 = \" is cool.\"\n",
    "print(string_1 + string_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "97996ea4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n"
     ]
    }
   ],
   "source": [
    "print(string_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "279e490f",
   "metadata": {},
   "source": [
    "* **The ```*``` Operator**\n",
    "\n",
    "The ```*``` operator creates multiple copies of a string. If s is a string and n is an integer, either of the following expressions returns a string consisting of n concatenated copies of s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "a64efba0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "staplerstaplerstaplerstapler\n"
     ]
    }
   ],
   "source": [
    "string = \"stapler\"\n",
    "print(string * 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a86f891",
   "metadata": {},
   "source": [
    "The multiplier operand n must be an integer. You’d think it would be required to be a positive integer, but amusingly, it can be zero or negative, in which case the result is an empty string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "7a69ea3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "string = \"covid-19\"\n",
    "print(string * -2)  # prints an empty string"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8f5a252",
   "metadata": {},
   "source": [
    "* **The ```in``` Operator**\n",
    "\n",
    "Python also provides a membership operator that can be used with strings. The ```in``` operator returns ```True``` if the first operand is contained within the second, and ```False``` otherwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "11ddb791",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "is the string in the first sentece:  True\n",
      "is the string in the second sentece:  False\n"
     ]
    }
   ],
   "source": [
    "string = \"foo\"\n",
    "first_sentence = \"That's  a good food.\"\n",
    "print(\"is the string in the first sentece: \", string in first_sentence)\n",
    "second_sentence = \"That's good for now.\"\n",
    "print(\"is the string in the second sentece: \", string in second_sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bde17c5c",
   "metadata": {},
   "source": [
    "* There is also a ```not in``` operator, which does the opposite:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "8832f0c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z is not in the string:  True\n"
     ]
    }
   ],
   "source": [
    "z = \"z\"\n",
    "string = \"abcd\"\n",
    "print(\"z is not in the string: \", z not in string )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fd196e1",
   "metadata": {},
   "source": [
    "* ## Indexing and Slicing\n",
    "\n",
    "In Python, strings are ordered sequences of character data, and thus can be indexed in this way. Individual elements in a string can be accessed using an index in square brackets. This is exactly analogous to accessing individual characters in a list. string indexing is zero-based as it is with lists.\n",
    "\n",
    "* ### Indexing\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.5089888b3d9f.png\" width=\"430\"/>\n",
    "</div>\n",
    "\n",
    "* ### Slicing\n",
    "\n",
    "<div>\n",
    "<img src=\"https://media.geeksforgeeks.org/wp-content/uploads/20201025141338/Screenshot584.png\" width=\"430\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "93caf4e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "second element:  h\n",
      "first to third elements:  xh\n",
      "till second element:  ex\n",
      "from third element:  ilarate\n"
     ]
    }
   ],
   "source": [
    "word = \"exhilarate\"\n",
    "print(\"second element: \", word[2])\n",
    "print(\"first to third elements: \", word[1:3])\n",
    "print(\"till second element: \", word[:2])\n",
    "print(\"from third element: \", word[3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b99d299",
   "metadata": {},
   "source": [
    "* **Specifying a Stride in a String Slice**\n",
    "\n",
    "There is one more variant of the slicing syntax to discuss. Adding an additional : and a third index designates a stride (also called a step), which indicates how many characters to jump after retrieving each character in the slice.\n",
    "\n",
    "For example, for the string ```'foobar'```, the slice ```0:6:2``` starts with the first character and ends with the last character (the whole string), and every second character is skipped. This is shown in the following diagram:\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.1fb308cf7573.png\" width=\"300\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "59859c72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "slicing with stride of 2:  foa\n"
     ]
    }
   ],
   "source": [
    "sample = \"foobar\"\n",
    "print(\"slicing with stride of 2: \", sample[0:6:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52b4a746",
   "metadata": {},
   "source": [
    "* **who can explain this? 😉**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "394f7592",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ommited first and second indice with stride of 5:  11111\n"
     ]
    }
   ],
   "source": [
    "numbers = '12345' * 5\n",
    "print(\"ommited first and second indice with stride of 5: \", numbers[::5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f35b17c",
   "metadata": {},
   "source": [
    "* ### Built-in String Functions\n",
    "\n",
    "As you saw in the tutorial on Basic Data Types in Python, Python provides many functions that are built-in to the interpreter and always available. Here are a few that work with strings:\n",
    "\n",
    "1. ```chr()```: Converts an integer to a character\n",
    "2. ```ord()```: Converts a character to an integer\n",
    "3. ```len()```: Returns the length of a string\n",
    "4. ```str()```: Returns a string representation of an object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68e9b5aa",
   "metadata": {},
   "source": [
    "* **```ord(c)```**\n",
    "\n",
    "Returns an integer value for the given character.\n",
    "\n",
    "At the most basic level, computers store all information as numbers. To represent character data, a translation scheme is used which maps each character to its representative number.\n",
    "\n",
    "The simplest scheme in common use is called ASCII. It covers the common Latin characters you are probably most accustomed to working with. For these characters, ```ord(c)``` returns the ASCII value for character ```c```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "dd9a6c8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "integer value of 'a':  97\n",
      "integer value of '$':  36\n"
     ]
    }
   ],
   "source": [
    "print(\"integer value of 'a': \", ord('a'))\n",
    "print(\"integer value of '$': \", ord('$'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0f79c12",
   "metadata": {},
   "source": [
    "* **```chr(n)```**\n",
    "\n",
    "Returns a character value for the given integer.\n",
    "\n",
    "```chr()``` does the reverse of ```ord()```. Given a numeric value ```n```, ```chr(n)``` returns a string representing the character that corresponds to ```n```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "7c2122f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unicode value of '97':  a\n",
      "unicode value of '8721':  ∑\n"
     ]
    }
   ],
   "source": [
    "print(\"unicode value of '97': \", chr(97))\n",
    "print(\"unicode value of '8721': \", chr(8721))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f53061aa",
   "metadata": {},
   "source": [
    "* **```len(s)```**\n",
    "\n",
    "Returns the length of a string.\n",
    "\n",
    "With ```len()```, you can check Python string length. ```len(s)``` returns the number of characters in ```s```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "c6e9d082",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of the given string is:  14\n"
     ]
    }
   ],
   "source": [
    "s = \"I am a string.\"\n",
    "print(\"length of the given string is: \", len(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d737d3c",
   "metadata": {},
   "source": [
    "* **```str(obj)```***\n",
    "\n",
    "Returns a string representation of an object.\n",
    "\n",
    "Virtually any object in Python can be rendered as a string. ```str(obj)``` returns the string representation of object ```obj```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "8e19770c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str() representation of a floating point number:  49.2\n",
      "str() representation of an integer number:  32\n",
      "str() representation of a string:  foo\n"
     ]
    }
   ],
   "source": [
    "print(\"str() representation of a floating point number: \", str(49.2))\n",
    "print(\"str() representation of an integer number: \", str(3 + 29))  # it will evaluate the expression and then prints it\n",
    "print(\"str() representation of a string: \", str('foo'))  # hence it is a str() object itself, this command does nothing "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ce1f6e1",
   "metadata": {},
   "source": [
    "* ### strings Methods\n",
    "\n",
    "1. ```capitalize()```: Converts the first character to upper case\n",
    "2. ```casefold()```: Converts string into lower case\n",
    "3. ```center()```: Returns a centered string\n",
    "4. ```count()```: Returns the number of times a specified value occurs in a string\n",
    "5. ```encode()```: Returns an encoded version of the string\n",
    "6. ```endswith()```: Returns true if the string ends with the specified value\n",
    "7. ```expandtabs()```: Sets the tab size of the string\n",
    "8. ```find()```: Searches the string for a specified value and returns the position of where it was found\n",
    "9. ```format()```: Formats specified values in a string\n",
    "10. ```format_map()```: Formats specified values in a string\n",
    "11. ```index()```: Searches the string for a specified value and returns the position of where it was found\n",
    "12. ```isalnum()```: Returns True if all characters in the string are alphanumeric\n",
    "13. ```isalpha()```: Returns True if all characters in the string are in the alphabet\n",
    "14. ```isdecimal()```: Returns True if all characters in the string are decimals\n",
    "15. ```isdigit()```: Returns True if all characters in the string are digits\n",
    "16. ```isidentifier()```: Returns True if the string is an identifier\n",
    "17. ```islower()```: Returns True if all characters in the string are lower case\n",
    "18. ```isnumeric()```: Returns True if all characters in the string are numeric\n",
    "19. ```isprintable()```: Returns True if all characters in the string are printable\n",
    "20. ```isspace()```: Returns True if all characters in the string are whitespaces\n",
    "21. ```istitle()```: Returns True if the string follows the rules of a title\n",
    "22. ```isupper()```: Returns True if all characters in the string are upper case\n",
    "23. ```join()```: Joins the elements of an iterable to the end of the string\n",
    "24. ```ljust()```: Returns a left justified version of the string\n",
    "25. ```lower()```: Converts a string into lower case\n",
    "26. ```lstrip()```: Returns a left trim version of the string\n",
    "27. ```maketrans()```: Returns a translation table to be used in translations\n",
    "28. ```partition()```: Returns a tuple where the string is parted into three parts\n",
    "29. ```replace()```: Returns a string where a specified value is replaced with a specified value\n",
    "30. ```rfind()```: Searches the string for a specified value and returns the last position of where it was found\n",
    "31. ```rindex()```: Searches the string for a specified value and returns the last position of where it was found\n",
    "32. ```rjust()```: Returns a right justified version of the string\n",
    "33. ```rpartition()```:\tReturns a tuple where the string is parted into three parts\n",
    "34. ```rsplit()```: Splits the string at the specified separator, and returns a list\n",
    "35. ```rstrip()```: Returns a right trim version of the string\n",
    "36. ```split()```: Splits the string at the specified separator, and returns a list\n",
    "37. ```splitlines()```: Splits the string at line breaks and returns a list\n",
    "38. ```startswith()```: Returns true if the string starts with the specified value\n",
    "39. ```strip()```: Returns a trimmed version of the string\n",
    "40. ```swapcase()```: Swaps cases, lower case becomes upper case and vice versa\n",
    "41. ```title()```: Converts the first character of each word to upper case\n",
    "42. ```translate()```: Returns a translated string\n",
    "43. ```upper()```: Converts a string into upper case\n",
    "44. ```zfill()```: Fills the string with a specified number of 0 values at the beginning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f91817d",
   "metadata": {},
   "source": [
    "* **```capitalize()```**\n",
    "\n",
    "The ```capitalize()``` method returns a string where the first character is upper case, and the rest is lower case.\n",
    "\n",
    "*   **syntax**: ```string.capitalize()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "dc9691a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python is fun!\n"
     ]
    }
   ],
   "source": [
    "text = \"python is FUN!\"\n",
    "capitalized_text = text.capitalize()\n",
    "print(capitalized_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b727a797",
   "metadata": {},
   "source": [
    "* **```casefold()```**\n",
    "\n",
    "The ```casefold()``` method returns a string where all the characters are lower case.\n",
    "\n",
    "This method is similar to the ```lower()``` method, but the ```casefold()``` method is stronger, more aggressive, meaning that it will convert more characters into lower case, and will find more matches when comparing two strings and both are converted using the ```casefold()``` method.\n",
    "\n",
    "*   **syntax**: string.casefold()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "2acbaede",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello, and welcome to my world!\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello, And Welcome To MY World!\"\n",
    "new_text = text.casefold()\n",
    "print(new_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2625f4a",
   "metadata": {},
   "source": [
    "* **```center()```**\n",
    "\n",
    "The ```center()``` method will center align the string, using a specified character (space is default) as the fill character.\n",
    "\n",
    "*   **syntax**: string.center(length, character)\n",
    "\n",
    "    length(Required): The length of the returned string\n",
    "    \n",
    "    character(Optional): The character to fill the missing space on each side. Default is ```\" \"``` (space)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "fb6c7a7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xxxxxxxbananaxxxxxxx\n"
     ]
    }
   ],
   "source": [
    "text = \"banana\"\n",
    "centered_text = text.center(20, \"x\")  # each x takes approximately 3 space unit.\n",
    "print(centered_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfedc36a",
   "metadata": {},
   "source": [
    "* **```count()```**\n",
    "\n",
    "The ```count()``` method returns the number of times a specified value appears in the string.\n",
    "\n",
    "*   **syntax**: string.count(value, start, end)\n",
    "\n",
    "    value(Required): A String. The string to value to search for\n",
    "    \n",
    "    start(Optional): An Integer. The position to start the search. Default is 0\n",
    "    \n",
    "    end(Optional): An Integer. The position to end the search. Default is the end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "2be81951",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple is repeated:  2 times in the given sentence.\n"
     ]
    }
   ],
   "source": [
    "text = \"I love apples, apple are my favorite fruit\"\n",
    "count_of_apples = text.count(\"apple\")\n",
    "print(\"apple is repeated: \", count_of_apples, \"times in the given sentence.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "826748c7",
   "metadata": {},
   "source": [
    "* **```encode()```**\n",
    "\n",
    "The ```encode()``` method encodes the string, using the specified encoding. If no encoding is specified, ```UTF-8``` will be used.\n",
    "\n",
    "*   **Syntax:** string.encode(encoding=encoding, errors=errors) \n",
    "\n",
    "    encoding(Optional): A String specifying the encoding to use. Default is UTF-8\n",
    "\n",
    "    errors(Optional): A String specifying the error method. Legal values are:\n",
    "\n",
    "                    \"backslashreplace\" : uses a backslash instead of the character that could not be encoded\n",
    "\n",
    "                    \"ignore\" : ignores the characters that cannot be encoded\n",
    "\n",
    "                    \"namereplace\" : replaces the character with a text explaining the character\n",
    "\n",
    "                    \"strict\" : Default, raises an error on failure\n",
    "\n",
    "                    \"replace\" : replaces the character with a questionmark\n",
    "\n",
    "                    \"xmlcharrefreplace\" : replaces the character with an xml character"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "a39b1e58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'My name is St\\\\xe5le'\n",
      "b'My name is Stle'\n",
      "b'My name is St\\\\N{LATIN SMALL LETTER A WITH RING ABOVE}le'\n",
      "b'My name is St?le'\n",
      "b'My name is St&#229;le'\n"
     ]
    }
   ],
   "source": [
    "text = \"My name is Ståle\"\n",
    "\n",
    "print(text.encode(encoding=\"ascii\",errors=\"backslashreplace\"))\n",
    "print(text.encode(encoding=\"ascii\",errors=\"ignore\"))\n",
    "print(text.encode(encoding=\"ascii\",errors=\"namereplace\"))\n",
    "print(text.encode(encoding=\"ascii\",errors=\"replace\"))\n",
    "print(text.encode(encoding=\"ascii\",errors=\"xmlcharrefreplace\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1463155e",
   "metadata": {},
   "source": [
    "* **```endswith()```**\n",
    "\n",
    "The ```endswith()``` method returns ```True``` if the string ends with the specified value, otherwise ```False```.\n",
    "\n",
    "*   **Syntax:** string.endswith(value, start, end) \n",
    "\n",
    "    value(Required) : The value to check if the string ends with\n",
    "\n",
    "    start(Optional) : An Integer specifying at which position to start the search\n",
    "\n",
    "    end(Optional) : An Integer specifying at which position to end the search\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "f7cb0dd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello, welcome to Class\"\n",
    "\n",
    "print(text.endswith(\"Class\"))\n",
    "print(text.endswith(\"Class\" , 5 ,9))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "237ce779",
   "metadata": {},
   "source": [
    "* **```expandtabs()```**\n",
    "\n",
    "The ```expandtabs()``` method sets the tab size to the specified number of whitespaces.\n",
    "\n",
    "*   **syntax:** string.expandtabs(tabsize)\n",
    "\n",
    "    tabsize(Optional) : A number specifying the tabsize. Default tabsize is 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "19eaba96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "intact text:        H\te\tl\tl\to\n",
      "tabsize = default:  H       e       l       l       o\n",
      "tabsize = 2:        H e l l o\n",
      "tabsize = 4:        H   e   l   l   o\n",
      "tabsize = 10:       H         e         l         l         o\n"
     ]
    }
   ],
   "source": [
    "text = \"H\\te\\tl\\tl\\to\"\n",
    "\n",
    "print(\"intact text:       \", text)\n",
    "print(\"tabsize = default: \", text.expandtabs())\n",
    "print(\"tabsize = 2:       \", text.expandtabs(2))\n",
    "print(\"tabsize = 4:       \", text.expandtabs(4))\n",
    "print(\"tabsize = 10:      \", text.expandtabs(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5a26650",
   "metadata": {},
   "source": [
    "* **```find()```**\n",
    "\n",
    "The ```find()``` method finds the first occurrence of the specified value.\n",
    "\n",
    "**Note: The ```find()``` method returns ```-1``` if the value is not found.**\n",
    "\n",
    "The ```find()``` method is almost the same as the ```index()``` method, the only difference is that the ```index()``` method raises an exception if the value is not found.\n",
    "\n",
    "*   **Syntax:** string.find(value, start, end)\n",
    "\n",
    "    value(Required) : The value to search for\n",
    "\n",
    "    start(Optional) : Where to start the search. Default is 0\n",
    "\n",
    "    end(Optional) : Where to end the search. Default is to the end of the string\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "b4b7573b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "1\n",
      "8\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "text = \"Hello, welcome to my Class\"\n",
    "print(text.find(\"welcome\"))\n",
    "print(text.find(\"e\"))\n",
    "print(text.find(\"e\", 5, 9))\n",
    "print(text.find(\"q\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68eb8cdf",
   "metadata": {},
   "source": [
    "* **```format()```**\n",
    "\n",
    "The ```format()``` method formats the specified value(s) and insert them inside the string's placeholder.\n",
    "\n",
    "The placeholder is defined using curly brackets: {}. Read more about the placeholders in the Placeholder section below.\n",
    "\n",
    "The ```format()``` method returns the formatted string.\n",
    "\n",
    "*   **syntax:** string.format(value1, value2...) \n",
    "\n",
    "    value1,value2,...(Required) : One or more values that should be formatted and inserted in the string.\n",
    "\n",
    "    The values are either a list of values separated by commas, a key=value list, or a combination of both.\n",
    "\n",
    "    The values can be of any data type.\n",
    "\n",
    "\n",
    "<mark>Note: The placeholders can be identified using named indexes {price}, numbered indexes {0}, or even empty placeholders {}.</mark>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "ce6f9752",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Alex\n",
      "My name is Alex, I'm 36\n",
      "My name is Alex, I'm 36\n",
      "My name is Alex, I'm 36\n"
     ]
    }
   ],
   "source": [
    "text1 = \"My name is {name}\"\n",
    "text2 = \"My name is {name}, I'm {age}\"\n",
    "text3 = \"My name is {0}, I'm {1}\"\n",
    "text4 = \"My name is {}, I'm {}\"\n",
    "print(text1.format(name = \"Alex\"))\n",
    "print(text2.format(name = \"Alex\" , age = 36))\n",
    "print(text3.format(\"Alex\" , 36))\n",
    "print(text4.format(\"Alex\" , 36))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0803da3",
   "metadata": {},
   "source": [
    "* **```index()```**\n",
    "\n",
    "The ```index()``` method finds the first occurrence of the specified value.\n",
    "\n",
    "The ```index()``` method raises an exception if the value is not found.\n",
    "\n",
    "The ```index()``` method is almost the same as the ```find()``` method, the only difference is that the ```find()``` method returns ```-1``` if the value is not found.\n",
    "\n",
    "*   **syntax:** string.index(value, start, end)\n",
    "\n",
    "    value(Required) : The value to search for\n",
    "\n",
    "    start(Optional) : Where to start the search. Default is 0\n",
    "\n",
    "    end(Optional) : Where to end the search. Default is to the end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "b2b0bc24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "1\n",
      "8\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "\u001B[1;32m~\\AppData\\Local\\Temp/ipykernel_10288/362042918.py\u001B[0m in \u001B[0;36m<module>\u001B[1;34m\u001B[0m\n\u001B[0;32m      3\u001B[0m \u001B[0mprint\u001B[0m\u001B[1;33m(\u001B[0m\u001B[0mtext\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mindex\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;34m\"e\"\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[0;32m      4\u001B[0m \u001B[0mprint\u001B[0m\u001B[1;33m(\u001B[0m\u001B[0mtext\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mindex\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;34m\"e\"\u001B[0m\u001B[1;33m,\u001B[0m \u001B[1;36m5\u001B[0m\u001B[1;33m,\u001B[0m \u001B[1;36m9\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[1;32m----> 5\u001B[1;33m \u001B[0mprint\u001B[0m\u001B[1;33m(\u001B[0m\u001B[0mtext\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mindex\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;34m\"q\"\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[0;32m      6\u001B[0m \u001B[0mprint\u001B[0m\u001B[1;33m(\u001B[0m\u001B[0mtext\u001B[0m\u001B[1;33m.\u001B[0m\u001B[0mfind\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;34m\"q\"\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[0;32m      7\u001B[0m \u001B[1;33m\u001B[0m\u001B[0m\n",
      "\u001B[1;31mValueError\u001B[0m: substring not found"
     ]
    }
   ],
   "source": [
    "text = \"Hello, welcome to my Class\"\n",
    "print(text.index(\"welcome\"))\n",
    "print(text.index(\"e\"))\n",
    "print(text.index(\"e\", 5, 9))\n",
    "print(text.index(\"q\"))\n",
    "print(text.find(\"q\")) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f71153a",
   "metadata": {},
   "source": [
    "* **```isalnum()```**\n",
    "\n",
    "The ```isalnum()``` method returns ```True``` if all the characters are alphanumeric, meaning alphabet letter (a-z) and numbers (0-9).\n",
    "\n",
    "Example of characters that are not alphanumeric: (space)!#%&? etc.\n",
    "\n",
    "*   **Syntax:** string.isalnum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6598d904",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"python3\"\n",
    "text2 = \"python 3\"\n",
    "print(text1.isalnum())\n",
    "print(text2.isalnum())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc9d6cae",
   "metadata": {},
   "source": [
    "* **```isalpha()```** \n",
    "\n",
    "The ```isalpha()``` method returns ```True``` if all the characters are alphabet letters (a-z).\n",
    "\n",
    "Example of characters that are not alphabet letters: (space)!#%&? etc.\n",
    "\n",
    "*   **Syntax:** string.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd2f755c",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"python\"\n",
    "text2 = \"python3\"\n",
    "print(text1.isalpha())\n",
    "print(text2.isalpha())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5a10823",
   "metadata": {},
   "source": [
    "* **```isdecimal()```**\n",
    "\n",
    "The ```isdecimal()``` method returns ```True``` if all the characters are decimals (0-9).\n",
    "\n",
    "<mark>**Note:** This method is used on unicode objects.</mark>\n",
    "\n",
    "*   **Syntax:** string.isdecimal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8f5a4a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"12345\" \n",
    "text2 = \"abcd\" \n",
    "\n",
    "print(text1.isdecimal())\n",
    "print(text2.isdecimal())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fe17fd3",
   "metadata": {},
   "source": [
    "* **```isdigit()```**\n",
    "\n",
    "The ```isdigit()``` method returns ```True``` if all the characters are digits.\n",
    "\n",
    "Exponents, like ², are also considered to be a digit.\n",
    "\n",
    "*   **Syntax:** string.isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecbd63e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"1000\"\n",
    "text2 = \"f1000\"\n",
    "print(text1.isdigit())\n",
    "print(text2.isdigit())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab343a8a",
   "metadata": {},
   "source": [
    "* **```isidentifier()```**\n",
    "\n",
    "The ```isidentifier()``` method returns ```True``` if the string is a valid identifier.\n",
    "\n",
    "A string is considered a valid identifier if it only contains alphanumeric letters (a-z) and (0-9), or underscores (_).\n",
    "\n",
    "A valid identifier cannot start with a number, or contain any spaces.\n",
    "\n",
    "*   **Syntax:** string.isidentifier()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbe0b043",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"python\"\n",
    "text2 = \"python3\"\n",
    "text3 = \"python 3\"\n",
    "text4 = \"3python\"\n",
    "print(text1.isidentifier())\n",
    "print(text2.isidentifier())\n",
    "print(text3.isidentifier())\n",
    "print(text4.isidentifier())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b67dc0f",
   "metadata": {},
   "source": [
    "* **```islower()```**\n",
    "\n",
    "The ```islower()``` method returns ```True``` if all the characters are in lower case.\n",
    "\n",
    "Numbers, symbols and spaces are not checked, only alphabet characters.\n",
    "\n",
    "*   **Syntax:** string.islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a9490bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"Hello world\"\n",
    "text2 = \"hello world\"\n",
    "print(text1.islower())\n",
    "print(text2.islower())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c2ce656",
   "metadata": {},
   "source": [
    "* **```isnumeric()```**\n",
    "\n",
    "The ```isnumeric()``` method returns True if all the characters are numeric (0-9).\n",
    "\n",
    "Exponents, like ```²``` and ```¾``` are also considered to be numeric values.\n",
    "\n",
    "**Note:** ```-1``` and ```1.5``` are NOT considered numeric values, because all the characters in the string must be numeric, and the ```-``` and the ```.``` are not.\n",
    "\n",
    "*   **Syntax:** string.isnumeric()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d27a8de",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"12345\"\n",
    "text2 = \"f12345\"\n",
    "text3 = \"abcd\"\n",
    "text4 = \"-12345\"\n",
    "text5 = \"12.345\"\n",
    "print(text1.isnumeric())\n",
    "print(text2.isnumeric())\n",
    "print(text3.isnumeric())\n",
    "print(text4.isnumeric())\n",
    "print(text5.isnumeric())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23c91aa4",
   "metadata": {},
   "source": [
    "* **```isprintable()```**\n",
    "\n",
    "The ```isprintable()``` method returns ```True``` if all the characters are printable.\n",
    "\n",
    "Example of none printable character can be carriage return and line feed.\n",
    "\n",
    "*   **Syntax:** string.isprintable()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f4cd5d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"Hello world\"\n",
    "text2 = \"Hello!\\nAre you #1?\"\n",
    "print(text1.isprintable())\n",
    "print(text2.isprintable())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7e89a81",
   "metadata": {},
   "source": [
    "* **```isspace()```**\n",
    "\n",
    "The ```isspace()``` method returns ```True``` if all the characters in a string are whitespaces.\n",
    "\n",
    "*   **Syntax:** string.isspace()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f2dde6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"     \"\n",
    "text2 = \"  f  \"\n",
    "print(text1.isspace())\n",
    "print(text2.isspace())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9d2ab69",
   "metadata": {},
   "source": [
    "* **```istitle()```**\n",
    "\n",
    "The ```istitle()``` method returns ```True``` if all words in a text start with a upper case letter, AND the rest of the word are lower case letters.\n",
    "\n",
    "<mark>**Note:** Symbols and numbers are ignored.</mark>\n",
    "\n",
    "*   **Syntax:** string.istitle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35a1ccd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"Hello World\"\n",
    "text2 = \"HELLO WORLD\"\n",
    "text3 = \"22 Names\"\n",
    "print(text1.istitle())\n",
    "print(text2.istitle())\n",
    "print(text3.istitle())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46aab818",
   "metadata": {},
   "source": [
    "* **```isupper()```**\n",
    "\n",
    "The ```isupper()``` method returns ```True``` if all the characters are in upper case.\n",
    "\n",
    "Numbers, symbols and spaces are not checked, only alphabet characters.\n",
    "\n",
    "*   **syntax:** string.isupper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e47b0f81",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"Hello World\"\n",
    "text2 = \"HELLO WORLD\"\n",
    "text3 = \"22 Names\"\n",
    "print(text1.isupper())\n",
    "print(text2.isupper())\n",
    "print(text3.isupper())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2ddf659",
   "metadata": {},
   "source": [
    "* **```join()```**\n",
    "\n",
    "The ```join()``` method takes all items in an iterable and joins them into one string.\n",
    "\n",
    "A string must be specified as the separator.\n",
    "\n",
    "*   **syntax:** string.join(iterable)\n",
    "\n",
    "    iterable(Required) : Any iterable object where all the returned values are strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6be6dea6",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (\"Hello\", \"welcome\", \"to\", \"my\", \"class\" )\n",
    "print(\"**\".join(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fe52a6a",
   "metadata": {},
   "source": [
    "* **```ljust()```**\n",
    "\n",
    "The ```ljust()``` method will left align the string, using a specified character (space is default) as the fill character.\n",
    "\n",
    "*   **syntax:** string.ljust(length, character)\n",
    "\n",
    "    length(Required) : The length of the returned string\n",
    "\n",
    "    character(Optional) : A character to fill the missing space (to the right of the string). Default is \" \" (space)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ca10178",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"banana\"\n",
    "print(text.ljust(10), \"is my favorite\")\n",
    "print(text.ljust(20, \"*\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48179ab9",
   "metadata": {},
   "source": [
    "* **```lower()```**\n",
    "\n",
    "The ```lower()``` method returns a string where all characters are lower case.\n",
    "\n",
    "Symbols and Numbers are ignored.\n",
    "\n",
    "*   **syntax:** string.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e2bb459",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"HELLO WORLD\"\n",
    "text2 = \"Hello World\"\n",
    "text3 = \"HELLO WORLD 12345\"\n",
    "print(text1.lower())\n",
    "print(text2.lower())\n",
    "print(text3.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2e68c98",
   "metadata": {},
   "source": [
    "* **```lstrip()```**\n",
    "\n",
    "The ```lstrip()``` method removes any leading characters (space is the default leading character to remove).\n",
    "\n",
    "*   **syntax:** string.lstrip(characters)\n",
    "\n",
    "    characters(Optional) : A set of characters to remove as leading characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "884ea64f",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"    banana    \"\n",
    "text2 = \"111112223333...banana\"\n",
    "print(text1.lstrip())\n",
    "print(text2.lstrip(\"123.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ec54704",
   "metadata": {},
   "source": [
    "* **```maketrans()```**\n",
    "\n",
    "The ```maketrans()``` method returns a mapping table that can be used with the ```translate()``` method to replace specified characters.\n",
    "\n",
    "*   **syntax:** string.maketrans(x, y, z) \n",
    "\n",
    "    x(Required) : If only one parameter is specified, this has to be a dictionary describing how to perform the replace. If two or more parameters are specified, this parameter has to be a string specifying the characters you want to replace.\n",
    "\n",
    "    y(Optional) : A string with the same length as parameter x. Each character in the first parameter will be replaced with the corresponding character in this string.\n",
    "\n",
    "    z(Optional) : A string describing which characters to remove from the original string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e4bc1bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hello Sam\"\n",
    "x = text.maketrans(\"S\", \"P\")\n",
    "print(text.translate(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa013757",
   "metadata": {},
   "source": [
    "* **```partition()```**\n",
    "\n",
    "The ```partition()``` method searches for a specified string, and splits the string into a tuple containing three elements:\n",
    "\n",
    "1. The first element contains the part before the specified string.\n",
    "\n",
    "2. The second element contains the specified string.\n",
    "\n",
    "3. The third element contains the part after the string.\n",
    "\n",
    "*   **syntax:** string.partition(value) \n",
    "\n",
    "    value(Required) : The string to search for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f383345c",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"I could eat bananas all day\"\n",
    "print(text.partition(\"bananas\"))\n",
    "print(text.partition(\"apples\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18c15362",
   "metadata": {},
   "source": [
    "* **```replace()```**\n",
    "\n",
    "The ```replace()``` method replaces a specified phrase with another specified phrase.\n",
    "\n",
    "*   **syntax:** string.replace(oldvalue, newvalue, count)\n",
    "\n",
    "    oldvalue(Required) : The string to search for\n",
    "\n",
    "    newvalue(Required) : The string to replace the old value with\n",
    "\n",
    "    count(Optional) : A number specifying how many occurrences of the old value you want to replace. Default is all occurrences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b913de2",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"one one was a race horse, two two was one too.\"\n",
    "print(text.replace(\"one\", \"three\"))\n",
    "print(text.replace(\"one\", \"three\", 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f2c5d6c",
   "metadata": {},
   "source": [
    "* **```rfind()```**\n",
    "\n",
    "The ```rfind()``` method finds the last occurrence of the specified value.\n",
    "\n",
    "The ```rfind()``` method returns ```-1``` if the value is not found.\n",
    "\n",
    "The ```rfind()``` method is almost the same as the ```rindex()``` method.\n",
    "\n",
    "*   **syntax:** string.rfind(value, start, end)\n",
    "\n",
    "    value(Required) : The value to search for\n",
    "\n",
    "    start(Optional) : Where to start the search. Default is 0\n",
    "\n",
    "    end(Optional) : Where to end the search. Default is to the end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0328e501",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hello, welcome to my Class\"\n",
    "print(text.rfind(\"e\"))\n",
    "print(text.rfind(\"e\", 5, 9))\n",
    "print(text.rfind(\"q\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51ddbe9a",
   "metadata": {},
   "source": [
    "* **```rindex()```**\n",
    "\n",
    "The ```rindex()``` method finds the last occurrence of the specified value.\n",
    "\n",
    "The ```rindex()``` method raises an exception if the value is not found.\n",
    "\n",
    "The ```rindex()``` method is almost the same as the ```rfind()``` method.\n",
    "\n",
    "*   **syntax:** string.rindex(value, start, end)\n",
    "\n",
    "    value(Required) : The value to search for\n",
    "\n",
    "    start(Optional) : Where to start the search. Default is 0\n",
    "\n",
    "    end(Optional) : Where to end the search. Default is to the end of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1213d4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hello, welcome to my Class\"\n",
    "print(text.rindex(\"e\"))\n",
    "print(text.rindex(\"e\", 5, 9))\n",
    "print(text.rindex(\"q\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07254dab",
   "metadata": {},
   "source": [
    "* **```rjust()```**\n",
    "\n",
    "The ```rjust()``` method will right align the string, using a specified character (space is default) as the fill character.\n",
    "\n",
    "*   **syntax:** string.rjust(length, character) \n",
    "\n",
    "    length(Required) : The length of the returned string\n",
    "\n",
    "    character(Optional) : A character to fill the missing space (to the left of the string). Default is \" \" (space)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24159e14",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"banana\"\n",
    "print(text.rjust(10), \"is my favorite\")\n",
    "print(text.rjust(20, \"*\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "357a3480",
   "metadata": {},
   "source": [
    "* **```rpartition()```**\n",
    "\n",
    "The ```rpartition()``` method searches for the last occurrence of a specified string, and splits the string into a tuple containing three elements: \n",
    "\n",
    "1. The first element contains the part before the specified string.\n",
    "\n",
    "2. The second element contains the specified string.\n",
    "\n",
    "3. The third element contains the part after the string.\n",
    "\n",
    "*   **syntax:** string.rpartition(value) \n",
    "\n",
    "    value(Required) : The string to search for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e50437a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"I could eat bananas all day\"\n",
    "print(text.rpartition(\"bananas\"))\n",
    "print(text.rpartition(\"apples\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "919b30da",
   "metadata": {},
   "source": [
    "* **```rslpit()```**\n",
    "\n",
    "The ```rsplit()``` method splits a string into a list, starting from the right.\n",
    "\n",
    "<mark>**Note:** If no \"max\" is specified, this method will return the same as the ```split()``` method.</mark>\n",
    "\n",
    "*   **syntax:** string.rsplit(separator, maxsplit)\n",
    "\n",
    "    separator(Optional) : Specifies the separator to use when splitting the string. By default any whitespace is a separator\n",
    "\n",
    "    maxsplit(Optional) : Specifies how many splits to do. Default value is -1, which is \"all occurrences\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b4b9fb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"apple, banana, cherry\"\n",
    "print(text.rsplit(\", \"))\n",
    "print(text.rsplit(\", \", 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddbef892",
   "metadata": {},
   "source": [
    "* **```rstrip()```**\n",
    "\n",
    "The ```rstrip()``` method removes any trailing characters (characters at the end a string), space is the default trailing character to remove.\n",
    "\n",
    "*   **syntax:** string.rstrip(characters) \n",
    "\n",
    "    characters(Optional) : A set of characters to remove as trailing characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74e80454",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"    banana    \"\n",
    "text2 =\"banana11122223333....\"\n",
    "print(text1.rstrip())\n",
    "print(text2.rstrip(\"123.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73d2353b",
   "metadata": {},
   "source": [
    "* **```split()```**\n",
    "\n",
    "The ```split()``` method splits a string into a list.\n",
    "\n",
    "<mark>**Note: You can specify the separator, default separator is any whitespace.**</mark>\n",
    "\n",
    "*   **syntax:** string.split(separator, maxsplit)\n",
    "\n",
    "    separator(Optional) : Specifies the separator to use when splitting the string. By default any whitespace is a separator\n",
    "\n",
    "    maxsplit(Optional) : Specifies how many splits to do. Default value is ```-1```, which is \"all occurrences\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee138d3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"apple#banana#cherry#orange\"\n",
    "print(text.rsplit(\"#\"))\n",
    "print(text.rsplit(\"#\", 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "378ed46f",
   "metadata": {},
   "source": [
    "* **```splitlines()```**\n",
    "\n",
    "The ```splitlines()``` method splits a string into a list. The splitting is done at line breaks.\n",
    "\n",
    "*   **syntax:** string.splitlines(keeplinebreaks)\n",
    "\n",
    "    keeplinebreaks(Optional) : Specifies if the line breaks should be included ```True```, or not ```False```. Default value is ```False```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96d02ce3",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Thank you for the music\\nWelcome to the jungle\"\n",
    "print(text.splitlines())\n",
    "print(text.splitlines(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34f90038",
   "metadata": {},
   "source": [
    "* **```startswith()```**\n",
    "\n",
    "The ```startswith()``` method returns ```True``` if the string starts with the specified value, otherwise ```False```.\n",
    "\n",
    "*   **syntax:** string.startswith(value, start, end) \n",
    "\n",
    "    value(Required) : The value to check if the string starts with\n",
    "\n",
    "    start(Optional) : An Integer specifying at which position to start the search\n",
    "\n",
    "    end(Optional) : An Integer specifying at which position to end the search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3d27dd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hello, welcome to my class.\"\n",
    "print(text.startswith(\"Hello\"))\n",
    "print(text.startswith(\"class\"))\n",
    "print(text.startswith(\"we\", 7, 20))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ead281a",
   "metadata": {},
   "source": [
    "* **```strip()```**\n",
    "\n",
    "The ```strip()``` method removes any leading (spaces at the beginning) and trailing (spaces at the end) characters (space is the default leading character to remove)\n",
    "\n",
    "*   **syntax:** string.strip(characters)\n",
    "\n",
    "    characters(Optional) : A set of characters to remove as leading/trailing characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51150b94",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"   banana   \"\n",
    "text2 = \"11122233...banana11122\"\n",
    "print(text1.strip())\n",
    "print(text2.strip(\"123.\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e9e48ec",
   "metadata": {},
   "source": [
    "* **```swapcase()```**\n",
    "\n",
    "The ```swapcase()``` method returns a string where all the upper case letters are lower case and vice versa.\n",
    "\n",
    "*   **syntax:** string.swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70cb6ea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hello, Welcome to My Class\"\n",
    "print(text.swapcase())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07201375",
   "metadata": {},
   "source": [
    "* **```title()```**\n",
    "\n",
    "The ```title()``` method returns a string where the first character in every word is upper case. Like a header, or a title.\n",
    "\n",
    "**Note:** If the word contains a number or a symbol, the first letter after that will be converted to upper case.\n",
    "\n",
    "*   **syntax:** string.title() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cea4a3df",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"hello, welcome to my class\"\n",
    "text2 = \"b2b2b2 and 3g3g3g\"\n",
    "print(text1.title())\n",
    "print(text2.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7b96f7c",
   "metadata": {},
   "source": [
    "* **```translate()```**\n",
    "\n",
    "The ```translate()``` method returns a string where some specified characters are replaced with the character described in a dictionary, or in a mapping table.\n",
    "\n",
    "Use the ```maketrans()``` method to create a mapping table.\n",
    "\n",
    "If a character is not specified in the dictionary/table, the character will not be replaced.\n",
    "\n",
    "<mark>**Note:** If you use a dictionary, you must use ascii codes instead of characters.</mark>\n",
    "\n",
    "*   **syntax:** string.translate(table)\n",
    "\n",
    "    table(Required) : Either a dictionary, or a mapping table describing how to perform the replace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c9fdff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hello Sam\"\n",
    "a = text.maketrans(\"S\", \"P\")\n",
    "print(text.translate(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e77eebd5",
   "metadata": {},
   "source": [
    "* **```upper()```**\n",
    "\n",
    "The ```upper()``` method returns a string where all characters are in upper case.\n",
    "\n",
    "**Note: Symbols and Numbers are ignored.**\n",
    "\n",
    "*   **syntax:** string.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5463b1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hello my friends\"\n",
    "print(text.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e77c8986",
   "metadata": {},
   "source": [
    "* **```zfill()```**\n",
    "\n",
    "The ```zfill()``` method adds zeros at the beginning of the string, until it reaches the specified length.\n",
    "\n",
    "If the value of the len parameter is less than the length of the string, no filling is done.\n",
    "\n",
    "*   **syntax:** string.zfill(len)\n",
    "\n",
    "    len(Required) : A number specifying the desired length of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8784d043",
   "metadata": {},
   "outputs": [],
   "source": [
    "text1 = \"hello\"\n",
    "text2 = \"welcome to the zoo\"\n",
    "text3 = \"20.000\"\n",
    "\n",
    "print(text1.zfill(10))\n",
    "print(text2.zfill(10))\n",
    "print(text3.zfill(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b5e6ac",
   "metadata": {},
   "source": [
    "***\n",
    "# set & frozenset class\n",
    "***\n",
    "\n",
    "Python’s ```set``` class represents the mathematical notion of a set, namely a collection of elements, **without duplicates**, and without an inherent order to those elements. The major advantage of using a set, as opposed to a list, is that it has a highly optimized method for checking whether a specific element is contained in the set. This is based on a data structure known as a hash table. However, there are two important restrictions due to the algorithmic underpinnings:\n",
    "\n",
    "1. The first is that the set does not maintain the elements in any particular order.\n",
    "\n",
    "2. The second is that only instances of immutable types can be added to a Python set.\n",
    "\n",
    "Therefore, objects such as integers, floating-point numbers, and character strings are eligible to be elements of a set. It is possible to maintain a set of tuples, but not a set of lists or a set of sets, as lists and sets are mutable. The ```frozenset``` class is an immutable form of the set type, so it is legal to have a set of frozensets.\n",
    "\n",
    "Python uses curly braces ```{ and }``` as delimiters for a set, for example, as ```{17}``` or ```{ red , green , blue }```. The exception to this rule is that ```{ }``` does not represent an empty set; for historical reasons, it represents an empty dictionary (see next topic). Instead, the constructor syntax ```set()``` produces an empty set. If an iterable parameter is sent to the constructor, then the set of distinct elements is produced. For example:\n",
    "\n",
    "```python\n",
    "set( hello )\n",
    "```\n",
    "\n",
    "produces:\n",
    "\n",
    "```python\n",
    "{ h , e , l , o }.\n",
    "```\n",
    "\n",
    "The important characteristics of Python sets are as follows:\n",
    "\n",
    "* Sets are unordered.\n",
    "* Set elements are unique. Duplicate elements are not allowed.\n",
    "* A set itself may be modified, but the elements contained in the set must be of an immutable type."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64868fa0",
   "metadata": {},
   "source": [
    "* ## Access Items\n",
    "\n",
    "You cannot access items in a set by referring to an index or a key.\n",
    "\n",
    "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": null,
   "id": "feeb046d",
   "metadata": {},
   "outputs": [],
   "source": [
    "transportation = {\"car\", \"plane\", \"ship\"}\n",
    "print(\"train\" in transportation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d759d75",
   "metadata": {},
   "outputs": [],
   "source": [
    "city = {\"park\", \"street\", \"hospital\"}\n",
    "for element in city:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc15efd2",
   "metadata": {},
   "source": [
    "* ## Set Methods\n",
    "\n",
    "1. ```add()```\n",
    "\n",
    "2. ```clear()```\n",
    "\n",
    "3. ```copy()```\n",
    "\n",
    "4. ```difference()```\n",
    "\n",
    "5. ```difference_update()```\n",
    "\n",
    "6. ```discard()```\n",
    "\n",
    "7. ```intersection()```\n",
    "\n",
    "8. ```intersection_update()```\n",
    "\n",
    "9. ```isdisjoint()```\n",
    "\n",
    "10. ```issubset()```\n",
    "\n",
    "11. ```issuperset()```\n",
    "\n",
    "12. ```pop()```\n",
    "\n",
    "13. ```remove()```\n",
    "\n",
    "14. ```symmetric_difference()```\n",
    "\n",
    "15. ```symmetric_difference_update()```\n",
    "\n",
    "16. ```union()```\n",
    "\n",
    "17. ```update()```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c943ee1",
   "metadata": {},
   "source": [
    "* **```add()```**\n",
    "\n",
    "The ```add()``` method adds an element to the set.\n",
    "\n",
    "If the element already exists, the ```add()``` method does not add the element.\n",
    "\n",
    "*   **Syntax:** set.add(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd13d531",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "fruits.add(\"orange\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2a659fb",
   "metadata": {},
   "source": [
    "* **```clear()```**\n",
    "\n",
    "The ```clear()``` method removes all elements in a set\n",
    "\n",
    "*   **Syntax:** set.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "676c47ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "fruits.clear()\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "531164e0",
   "metadata": {},
   "source": [
    "* **```copy```**\n",
    "\n",
    "The ```copy()``` method copies the set.\n",
    "\n",
    "*   **Syntax:** set.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2d37b92",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "fruits_copy = fruits.copy()\n",
    "print(fruits_copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85559509",
   "metadata": {},
   "source": [
    "* **```difference()```**\n",
    "\n",
    "The ```difference()``` method returns a set that contains the difference between two sets.\n",
    "\n",
    "Meaning: The returned set contains items that exist only in the first set, and not in both sets.\n",
    "\n",
    "*   **Syntax:** set.difference(set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bec878d",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "difference = fruits.difference(tech_companies)\n",
    "print(difference)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e862708",
   "metadata": {},
   "source": [
    "* **```difference_update()```**\n",
    "\n",
    "The ```difference_update()``` method removes the items that exist in both sets.\n",
    "\n",
    "<mark>**Note: The ```difference_update()``` method is different from the ```difference()``` method, because the ```difference()``` method returns a new set, without the unwanted items, and the ```difference_update()``` method removes the unwanted items from the original set.**</mark>\n",
    "\n",
    "*   **Syntax:** set.difference_update(set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b61b94a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "difference = fruits.difference_update(tech_companies)  # returns None\n",
    "print(difference)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69403520",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "fruits.difference_update(tech_companies)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fb60915",
   "metadata": {},
   "source": [
    "* **```discard()```**\n",
    "\n",
    "The ```discard()``` method removes the specified item from the set.\n",
    "\n",
    "**Note:** This method is different from the ```remove()``` method, because the ```remove()``` method will raise an error if the specified item does not exist, and the ```discard()``` method will not.\n",
    "\n",
    "*   **Syntax:** set.discard(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0f6b593",
   "metadata": {},
   "outputs": [],
   "source": [
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "tech_companies.discard(\"apple\")\n",
    "print(tech_companies)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "466a3135",
   "metadata": {},
   "source": [
    "* **```intersection```**\n",
    "\n",
    "The ```intersection()``` method returns a set that contains the similarity between two or more sets.\n",
    "\n",
    "Meaning: The returned set contains only items that exist in both sets, or in all sets if the comparison is done with more than two sets.\n",
    "\n",
    "*   **Syntax:** set.intersection(set1, set2 ... etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fad69c44",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "intersection = fruits.intersection(tech_companies)\n",
    "print(intersection)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad99ee9",
   "metadata": {},
   "source": [
    "* **```intersection_update()```**\n",
    "\n",
    "The ```intersection_update()``` method removes the items that is not present in both sets (or in all sets if the comparison is done between more than two sets).\n",
    "\n",
    "The ```intersection_update()``` method is different from the ```intersection()``` method, because the ```intersection()``` method returns a new set, without the unwanted items, and the ```intersection_update()``` method removes the unwanted items from the original set.\n",
    "\n",
    "*   **Syntax:** set.intersection_update(set1, set2 ... etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62da4f28",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "fruits.intersection_update(tech_companies)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1ffec13",
   "metadata": {},
   "source": [
    "* **```isdisjoint```**\n",
    "\n",
    "The ```isdisjoint()``` method returns ```True``` if none of the items are present in both sets, otherwise it returns ```False```.\n",
    "\n",
    "* **Syntax:** set.isdisjoint(set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74aa7f57",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "flag = fruits.isdisjoint(tech_companies)\n",
    "if flag is True:\n",
    "    print(\"they are disjoint.\")\n",
    "if flag is False:\n",
    "    print(\"they are not disjoint.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "980f0bc7",
   "metadata": {},
   "source": [
    "* **```issubset()```**\n",
    "\n",
    "The ```issubset()``` method returns ```True``` if all items in the set exists in the specified set, otherwise it retuns ```False```.\n",
    "\n",
    "*   **Syntax:** set.issubset(set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36cd90f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {\"a\", \"b\", \"c\"}\n",
    "y = {\"f\", \"e\", \"d\", \"c\", \"b\", \"a\"}\n",
    "print(x.issubset(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "320088cd",
   "metadata": {},
   "source": [
    "* **```issuperset()```**\n",
    "\n",
    "The ```issuperset()``` method returns ```True``` if all items in the specified set exists in the original set, otherwise it retuns ```False```.\n",
    "\n",
    "*   **Syntax:** set.issuperset(set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed8b8427",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {\"f\", \"e\", \"d\", \"c\", \"b\", \"a\"}\n",
    "y = {\"a\", \"b\", \"c\"}\n",
    "print(x.issuperset(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6beccbfc",
   "metadata": {},
   "source": [
    "* **```pop()```**\n",
    "\n",
    "The ```pop()``` method removes a **random** item from the set.\n",
    "\n",
    "This method returns the removed item.\n",
    "\n",
    "*   **Syntax:** set.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a364aadc",
   "metadata": {},
   "outputs": [],
   "source": [
    "cars = {\"bmw\", \"mercedes\", \"volvo\"}\n",
    "popped = cars.pop()\n",
    "print(\"set: \", cars)\n",
    "print(\"popped item: \", popped)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4c1e1cd",
   "metadata": {},
   "source": [
    "* **```remove()```**\n",
    "\n",
    "The ```remove()``` method removes the specified element from the set.\n",
    "\n",
    "This method is different from the ```discard()``` method, because the ```remove()``` method will raise an error if the specified item does not exist, and the ```discard()``` method will not.\n",
    "\n",
    "*   **Syntax:** set.remove(item)\n",
    "\n",
    "    item(Required): The item to search for, and remove."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33349376",
   "metadata": {},
   "outputs": [],
   "source": [
    "cars = {\"bmw\", \"mercedes\", \"volvo\"}\n",
    "cars.remove(\"bmw\")\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96bf545c",
   "metadata": {},
   "source": [
    "* **```symmetric_difference()```**\n",
    "\n",
    "The ```symmetric_difference()``` method returns a set that contains all items from both set, but not the items that are present in both sets.\n",
    "\n",
    "Meaning: The returned set contains a mix of items that are not present in both sets.\n",
    "\n",
    "*   **Syntax:** set.symmetric_difference(set)\n",
    "\n",
    "    set(Required): The set to check for matches in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91d68fcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "symmetric_difference = fruits.symmetric_difference(tech_companies)\n",
    "print(symmetric_difference)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b28aee9",
   "metadata": {},
   "source": [
    "* **```symmetric_difference_update()```**\n",
    "\n",
    "The ```symmetric_difference_update()``` method updates the original set by removing items that are present in both sets, and inserting the other items.\n",
    "\n",
    "*   **Syntax:** set.symmetric_difference_update(set)\n",
    "\n",
    "    set(Required): The set to check for matches in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23ef227d",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "fruits.symmetric_difference_update(tech_companies)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6592de7",
   "metadata": {},
   "source": [
    "* **```union()```**\n",
    "\n",
    "The ```union()``` method returns a set that contains all items from the original set, and all items from the specified set(s).\n",
    "\n",
    "You can specify as many sets you want, separated by commas.\n",
    "\n",
    "<mark>**Note:** It does not have to be a set, it can be any iterable object.</mark>\n",
    "\n",
    "If an item is present in more than one set, the result will contain only one appearance of this item.\n",
    "\n",
    "*   **Syntax:** set.union(set1, set2...)\n",
    "\n",
    "    set1(Required): The iterable to unify with\n",
    "    \n",
    "    set2(Optional): The other iterable to unify with. You can compare as many iterables as you like. Separate each iterable with a comma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3435b0b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {\"a\", \"b\", \"c\"}\n",
    "y = {\"f\", \"d\", \"a\"}\n",
    "z = {\"c\", \"d\", \"e\"}\n",
    "result = x.union(y, z)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efa4d7b4",
   "metadata": {},
   "source": [
    "* **```update()```**\n",
    "\n",
    "The ```update()``` method updates the current set, by adding items from another set (or any other iterable).\n",
    "\n",
    "If an item is present in both sets, only one appearance of this item will be present in the updated set.\n",
    "\n",
    "*   **Syntax:** set.update(set)\n",
    "\n",
    "    set(Required): The iterable insert into the current set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "deed35c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "tech_companies = {\"google\", \"microsoft\", \"apple\"}\n",
    "fruits.update(tech_companies)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0be5603a",
   "metadata": {},
   "source": [
    "***\n",
    "## dictionary class\n",
    "***\n",
    "\n",
    "Python’s ```dict``` class represents a dictionary, or mapping, from a set of distinct keys to associated values. For example, a dictionary might map from unique student ID numbers, to larger student records (such as the student’s name, address, and course\n",
    "grades). Python implements a dict using an almost identical approach to that of a set, but with storage of the associated values.\n",
    "\n",
    "A dictionary literal also uses curly braces, and because dictionaries were introduced in Python prior to sets, the literal form ```{ }``` produces an empty dictionary.\n",
    "\n",
    "A nonempty dictionary is expressed using a comma-separated series of ```key: value``` pairs. For example, the dictionary:\n",
    "```python\n",
    "{\"ga\": \"Irish\", \"de\": \"German\"}\n",
    "``` \n",
    "maps ```\"ga\"``` to ```\"Irish\"``` and ```\"de\"``` to ```\"German\"```.\n",
    "\n",
    "The constructor for the ```dict``` class accepts an existing mapping as a parameter, in which case it creates a new dictionary with identical associations as the existing one.\n",
    "\n",
    "<div>\n",
    "<img src=\"https://files.realpython.com/media/t.b3e3d8f2d100.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "Alternatively, the constructor accepts a sequence of key-value pairs as a parameter, as in ```dict(pairs)``` with ```pairs = [(\"ga\" , \"Irish\"), (\"de\" , \"German\")]```.\n",
    "\n",
    "Dictionaries and lists share the following characteristics:\n",
    "\n",
    "* Both are mutable.\n",
    "* Both are dynamic. They can grow and shrink as needed.\n",
    "* Both can be nested. A list can contain another list. A dictionary can contain another dictionary. A dictionary can also contain a list, and vice versa.\n",
    "\n",
    "Dictionaries differ from lists primarily in how elements are accessed:\n",
    "\n",
    "* List elements are accessed by their position in the list, via indexing.\n",
    "* Dictionary elements are accessed via keys."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0161658c",
   "metadata": {},
   "source": [
    "* ## Accessing Items\n",
    "\n",
    "You can access the items of a dictionary by referring to its key name, inside square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ece72ed6",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "print(\"the car model is: \", car[\"model\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a240f326",
   "metadata": {},
   "source": [
    "<mark>**Note:** There is also a method called ```get()``` that will give you the same result.</mark>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1acb49d1",
   "metadata": {},
   "source": [
    "* ## Check if Key Exists\n",
    "\n",
    "To determine if a specified key is present in a dictionary use the ```in``` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39986aa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "if \"year\" in car:\n",
    "  print(\"year is one of the keys in the dictionary\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebc62c01",
   "metadata": {},
   "source": [
    "* ## Change Values\n",
    "\n",
    "You can change the value of a specific item by referring to its key name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cb664a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "car[\"year\"] = 2021\n",
    "print(\"after changing the year key's value: \", car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c838d27f",
   "metadata": {},
   "source": [
    "<mark>**Note:** There is also a method called ```update()``` that will give you the same result.</mark>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2ede80f",
   "metadata": {},
   "source": [
    "* ## Adding Items\n",
    "\n",
    "Adding an item to the dictionary is done by using a new index key and assigning a value to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e83a896e",
   "metadata": {},
   "outputs": [],
   "source": [
    "car[\"color\"] = \"matte black\"\n",
    "print(\"after adding the color key: \", car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "319a9064",
   "metadata": {},
   "source": [
    "<mark>**Note:** There is also a method called ```update()``` that will give you the same result.</mark>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4dd58f1",
   "metadata": {},
   "source": [
    "* ## Removing Items\n",
    "\n",
    "There are several methods to remove items from a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5395e9f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "del car[\"model\"]\n",
    "print(\"after removing the model (key, value) pair: \", car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2053ef94",
   "metadata": {},
   "source": [
    "<mark>**Note:** The ```del``` keyword can also delete the dictionary completely:</mark>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e759986",
   "metadata": {},
   "outputs": [],
   "source": [
    "del car\n",
    "print(car)  # will raise an error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c595a66",
   "metadata": {},
   "source": [
    "<mark>**Note:** There is also two method called ```pop()``` and ```popitem()``` that will give you the same result.</mark>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a73a1e04",
   "metadata": {},
   "source": [
    "* ## Dictionary Methods\n",
    "\n",
    "1. ```clear()```: Removes all the elements from the dictionary\n",
    "\n",
    "2. ```copy()```: Returns a copy of the dictionary\n",
    "\n",
    "3. ```fromkeys()```: Returns a dictionary with the specified keys and value\n",
    "\n",
    "4. ```get()```: Returns the value of the specified key\n",
    "\n",
    "5. ```items()```: Returns a list containing a tuple for each key value pair\n",
    "\n",
    "6. ```keys()```: Returns a list containing the dictionary's keys\n",
    "\n",
    "7. ```pop()```: Removes the element with the specified key\n",
    "\n",
    "8. ```popitem()```: Removes the last inserted key-value pair\n",
    "\n",
    "9. ```setdefault()```: Returns the value of the specified key. If the key does not exist: insert the key, with the specified value\n",
    "\n",
    "10. ```update()```: Updates the dictionary with the specified key-value pairs\n",
    "\n",
    "11. ```values()```: Returns a list of all the values in the dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e32f1f3d",
   "metadata": {},
   "source": [
    "* **```clear()```**\n",
    "\n",
    "The ```clear()``` method removes all the elements from a dictionary.\n",
    "\n",
    "*   **syntax:** dictionary.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34adc7d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "print(car.clear())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7a5d439",
   "metadata": {},
   "source": [
    "* **```copy()```**\n",
    "\n",
    "The ```copy()``` method returns a copy of the specified dictionary.\n",
    "\n",
    "*   **syntax:** dictionary.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bd3cdf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "x = car.copy()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7710531",
   "metadata": {},
   "source": [
    "* **```fromkeys()```**\n",
    "\n",
    "The ```fromkeys()``` method returns a dictionary with the specified keys and the specified value.\n",
    "\n",
    "*   **syntax:** dict.fromkeys(keys, value)\n",
    "\n",
    "    keys(Required) : An iterable specifying the keys of the new dictionary\n",
    "\n",
    "    value(Optional) : The value for all keys. Default value is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5b85d0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ('key1', 'key2', 'key3')\n",
    "b = 0\n",
    "print(dict.fromkeys(a))\n",
    "print(dict.fromkeys(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34dbadd8",
   "metadata": {},
   "source": [
    "* **```get()```**\n",
    "\n",
    "The ```get()``` method returns the value of the item with the specified key.\n",
    "\n",
    "*   **syntax:** dictionary.get(keyname, value)\n",
    "\n",
    "    keyname(Required) : The keyname of the item you want to return the value from\n",
    "\n",
    "    value(Optional) : A value to return if the specified key does not exist.\n",
    "                  Default value None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7049a08f",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "print(car.get(\"model\"))\n",
    "print(car.get(\"price\", 1500))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61068691",
   "metadata": {},
   "source": [
    "* **```items()```**\n",
    "\n",
    "The ```items()``` method returns a view object. The view object contains the key-value pairs of the dictionary, as tuples in a list.\n",
    "\n",
    "The view object will reflect any changes done to the dictionary.\n",
    "\n",
    "*   **syntax:** dictionary.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c348aad",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "print(car.items())\n",
    "\n",
    "x = car.items()\n",
    "car[\"year\"] = 2021\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10034124",
   "metadata": {},
   "source": [
    "* **```keys()```**\n",
    "\n",
    "The ```keys()``` method returns a view object. The view object contains the keys of the dictionary, **as a list**.\n",
    "\n",
    "The view object will reflect any changes done to the dictionary.\n",
    "\n",
    "*   **syntax:** dictionary.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e1225c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "print(car.keys())\n",
    "\n",
    "x = car.keys()\n",
    "car[\"color\"] = \"red\"\n",
    "print(car)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9915fa8",
   "metadata": {},
   "source": [
    "* **```pop()```**\n",
    "\n",
    "The ```pop()``` method removes the specified item from the dictionary.\n",
    "\n",
    "The value of the removed item is the return value of the ```pop()``` method.\n",
    "\n",
    "*   **syntax:** dictionary.pop(keyname, defaultvalue)\n",
    "\n",
    "    keyname(Required) : The keyname of the item you want to remove\n",
    "\n",
    "    defaultvalue(Optional) : A value to return if the specified key do not exist.\n",
    "\n",
    "                       If this parameter is not specified, and no item with the specified key is found, an error is raised"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12a6c851",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "x = car.pop(\"year\")\n",
    "print(x)\n",
    "print(car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "089b5960",
   "metadata": {},
   "source": [
    "* **```popitem()```**\n",
    "\n",
    "The ```popitem()``` method removes the item that was last inserted into the dictionary. In versions before 3.7, the ```popitem()``` method removes a random item.\n",
    "\n",
    "The removed item is the return value of the ```popitem()``` method, as a tuple.\n",
    "\n",
    "*   **syntax:** dictionary.popitem() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "380890f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "popped = car.popitem()\n",
    "print(popped)\n",
    "print(car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81eb453d",
   "metadata": {},
   "source": [
    "* **```setdefault()```**\n",
    "\n",
    "The ```setdefault()``` method returns the value of the item with the specified key.\n",
    "\n",
    "If the key does not exist, insert the key, with the specified value.\n",
    "\n",
    "*   **syntax:** dictionary.setdefault(keyname, value)\n",
    "\n",
    "    keyname(Required) : The keyname of the item you want to return the value from\n",
    "\n",
    "    value(Optional) : 1. If the key exist, this parameter has no effect.\n",
    "\n",
    "                  2. If the key does not exist, this value becomes the key's value\n",
    "\n",
    "                  3. Default value None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d24f4e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "print(car.setdefault(\"model\", \"Bronco\"))\n",
    "print(car.setdefault(\"color\", \"White\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "615974ed",
   "metadata": {},
   "source": [
    "* **```update()```**\n",
    "\n",
    "The ```update()``` method inserts the specified items to the dictionary.\n",
    "\n",
    "The specified items can be a dictionary, or an iterable object with key value pairs.\n",
    "\n",
    "*   **syntax:** dictionary.update(iterable)\n",
    "\n",
    "    iterable : A dictionary or an iterable object with key value pairs, that will be inserted to the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc866ff0",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "car.update({\"color\": \"White\"})\n",
    "print(car)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f290ec69",
   "metadata": {},
   "source": [
    "* **```values()```**\n",
    "\n",
    "The ```values()``` method returns a view object. The view object contains the values of the dictionary, **as a list**.\n",
    "\n",
    "The view object will reflect any changes done to the dictionary.\n",
    "\n",
    "*   **syntax:** dictionary.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55a36f83",
   "metadata": {},
   "outputs": [],
   "source": [
    "car = {\"brand\": \"Ford\", \"model\": \"Mustang\", \"year\": 1964}\n",
    "x = car.values()\n",
    "print(x)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}