str_set_list_dict.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "str_set_list_dict.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import random"
      ],
      "metadata": {
        "id": "rzg0wtvBPrL6"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Slicing in Python\n",
        "\n"
      ],
      "metadata": {
        "id": "uxCkvmO4Oo3s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = [2,3,4,5]\n",
        "\n",
        "print(x[-1])  #5  #  print last value stored in x\n",
        "print(x[-4])  #2  #  print first value\n",
        "print(x[0])   #2  #  print first value\n",
        "print(x[3])   #5  #  print last value stored in x\n",
        "\n",
        "print(x[:]) #[2, 3, 4, 5]\n",
        "print(x[2:]) #[4, 5] #From index_2 (incluse) to the end\n",
        "print(x[:2]) # [2, 3] # all before of index_2\n",
        "print(x[1:4]) # [3, 4, 5]\n",
        "print(x[1:4:2]) # [3, 5]"
      ],
      "metadata": {
        "id": "RAVIyT2xOyV4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Slicing in Numpy"
      ],
      "metadata": {
        "id": "mrfMCVrfPDSB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "patterns_W1 = np.array([[72, 173], [54, 159], [65, 172], [58, 170],[62, 165], [72, 176], [60, 173], [64, 179]])\n",
        "\n",
        "print(patterns_W1[:, 0]) #[72 54 65 58 62 72 60 64]\n",
        "print(patterns_W1[0, 0]) #72\n",
        "print(patterns_W1[:, 1]) #[173 159 172 170 165 176 173 179]"
      ],
      "metadata": {
        "id": "vZNggLjVO8Cb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Miscellaneous on Strings"
      ],
      "metadata": {
        "id": "DWUgbsjuPJG-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#invert string\n",
        "string = 'hello! this is a string 123'\n",
        "print(string[::-1])\n",
        "# \"classic\"  alternative\n",
        "s1= ''\n",
        "for i in range(1,len(string)+1):\n",
        "  k = len(string)-i\n",
        "  s1 = s1 + string[k]\n",
        "print(s1) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "da8NjImRPIq0",
        "outputId": "2090e650-c109-444d-f188-b4473b595ade"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "321 gnirts a si siht !olleh\n",
            "321 gnirts a si siht !olleh\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#repeat the string several times\n",
        "print(string *5) \n",
        "\n",
        "#concatenate strings\n",
        "s2 = string + \"Now_? \" + \"63\" + \"\\t\" + \"***\"\n",
        "print(s2) # hello! this is a string 123Now_? 63\t***\n",
        "\n",
        "#check in string \n",
        "x = \"this\" in string\n",
        "print(x) #  True\n",
        "x = \"this\" not in string\n",
        "print(x) #  False\n",
        "\n",
        "#Create a string of 10 randomly chosen characters from 'ABC&/()9'\n",
        "s3 = ''.join([random.choice('ABC&/695+<>') for i in range(10)])\n",
        "print(s3)\n",
        "\n",
        "#string comprehension\n",
        "numbers = [10,2,3,5,9]\n",
        "st =  '°'.join(str(x) for x in numbers)\n",
        "print(st) #out : 10°2°3°5°9\n",
        "\n",
        "#Convert a string in a list of separate characters\n",
        "l = list(string) \n",
        "print(l)\n",
        "#['h', 'e', 'l', 'l', 'o', '!', ' ', 't', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 's', 't', 'r', 'i', 'n', 'g', ' ', '1', '2', '3']"
      ],
      "metadata": {
        "id": "N6SZioZGPbi1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Given a string, the single words become elements of a list. \n",
        "#An optional argument called delimiter specifies which character should be considered as a word separator.\n",
        "s4 = 'Ciao-sono-    Mario-^ ! ^'\n",
        "deli = '-' # #you have a different output if you use: deli = ' '\n",
        "l = s4.split(deli)\n",
        "print(l)# out ['Ciao', 'sono', '    Mario', '^ ! ^']\n",
        "\n",
        "#join is the inverse of split: list -> string\n",
        "s5 = deli.join(l)\n",
        "print(s5)\n",
        "#print(type(s5)) #<class 'str'>\n",
        "\n",
        "#creative use of .join\n",
        "print(\"\")\n",
        "addresses=(\"Mr.Mario\", \"libero.com\")\n",
        "email='@'.join(addresses) \n",
        "email1 = '*'.join(email)  \n",
        "email2 ='\\n [...]'.join(addresses)\n",
        "print(email,\"\\n\\n\",email1,\"\\n\\n\",email2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7IZ52SvUQhSN",
        "outputId": "46cda374-4760-48b7-e0a8-f13a4cc994ba"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Ciao', 'sono', '    Mario', '^ ! ^']\n",
            "Ciao-sono-    Mario-^ ! ^\n",
            "\n",
            "Mr.Mario@libero.com \n",
            "\n",
            " M*r*.*M*a*r*i*o*@*l*i*b*e*r*o*.*c*o*m \n",
            "\n",
            " Mr.Mario\n",
            " [...]libero.com\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#use of .replace\n",
        "string = 'hello! this is a string 123'\n",
        "string = string.replace('l','§').replace('2',' ')\n",
        "print(string,\"\\n\") \n",
        "\n",
        "# cleans the string making all characters lowercase\n",
        "string1 = 'NOw,/is the=tIM<e> to\"gO'\n",
        "string1 =  string1.lower().replace(\"<\", \"\").replace(\">\", \"\").replace(\"=\", \" \").replace(\"/\", \" \").replace('\"', \" \")\n",
        "print(string1,\"\\n\")\n",
        "\n",
        "#Print string without going newline (end = \"\") up to a '1' terminator character\n",
        "i=0\n",
        "while  True:\n",
        "    if (string[i]=='1'):\n",
        "      break\n",
        "    print(string[i],end=\" \")\n",
        "    i+=1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x2s0NhMyRA-O",
        "outputId": "e3f6269b-8461-4550-9448-e7d6b3e9bab5"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "he§§o! this is a string 1 3 \n",
            "\n",
            "now, is the time to go \n",
            "\n",
            "h e § § o !   t h i s   i s   a   s t r i n g   "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Set"
      ],
      "metadata": {
        "id": "QlitDR5mRlr7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Create an empty set \n",
        "sx = set()\n",
        "print(type(sx))\n",
        "sx.add(\"Ciao\") #add element\n",
        "print(sx) \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KkZiWktgRgks",
        "outputId": "1695fa1f-1c4c-4fd3-cbaa-5111670e713c"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'set'>\n",
            "{'Ciao'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Miscellaneous on Lists"
      ],
      "metadata": {
        "id": "Qu_mW6oaRsUd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Given two list of integer, write a program  to  eliminate repetitions and make a list whose elements are intersection of the above given lists.\n",
        "la = [1,1,2,3,3,24,78,78,35,55]\n",
        "lb = [12,24,24,35,24,88,120,120,155]\n",
        "set1=set(la)\n",
        "set2=set(lb)\n",
        "set3 = set1 & set2\n",
        "li=list(set3)\n",
        "print(li,\"\\n\")\n",
        "\n",
        "#alternative\n",
        "set4 = set (i for i in la if i in lb) \n",
        "li1=list(set4)\n",
        "print(li1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nZ7xhiLVR5o6",
        "outputId": "00d99028-be25-47f1-d1ca-2b7d671af9e0"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[24, 35] \n",
            "\n",
            "[24, 35]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Get a list of numbers as input from a user \n",
        "input_string = input('Enter elements of a list separated by space ')\n",
        "print(\"\\n\")\n",
        "user_list = input_string.split()\n",
        "# print list\n",
        "print('list: ', user_list)"
      ],
      "metadata": {
        "id": "ks7TbmExSIeK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Modify list\n",
        "\n",
        "g = ['Nicola 2Van','Lynn Hill','Frederick Austerlitz']\n",
        "\n",
        "# add item\n",
        "g[1] = 'Ursula Benni' # replaces Lynn Hill of with Ursula Benni\n",
        "g.insert(1, 'Nack Irner') #  is inserted at index 1 (2th position)\n",
        "g.insert(0, 'Primo Nino')  #  is inserted at index 0 (1th position)\n",
        "g.append('Carlos De Mayo')\n",
        "g.append('Elizabeth Peratrovich')\n",
        "print(g,\"\\n\")\n",
        "\n",
        "#delete item\n",
        "g.remove('Frederick Austerlitz') \n",
        "g.pop() # delete the last item : 'Elizabeth Peratrovich Z'\n",
        "print(g)\n",
        "\n",
        "#on the list\n",
        "g.reverse() \n",
        "print(g) \n",
        "print(\"\\n\",g.index('Primo Nino'))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B0ARE3BqSLWD",
        "outputId": "3a7f0980-a655-45e2-b198-add4b9fc7900"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Primo Nino', 'Nicola 2Van', 'Nack Irner', 'Ursula Benni', 'Frederick Austerlitz', 'Carlos De Mayo', 'Elizabeth Peratrovich'] \n",
            "\n",
            "['Primo Nino', 'Nicola 2Van', 'Nack Irner', 'Ursula Benni', 'Carlos De Mayo']\n",
            "['Carlos De Mayo', 'Ursula Benni', 'Nack Irner', 'Nicola 2Van', 'Primo Nino']\n",
            "\n",
            " 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "k = g[:] # copy list g. Note id(k) is different to id(g)\n",
        "\n",
        "k = sorted(k, reverse = True) #reorders the list in reverse alphabetical order\n",
        "print(k)\n",
        "\n",
        "#Emptyn all list\n",
        "k.clear()#The clear() method removes all items\n",
        "print(k)\n",
        "\n",
        "#Empty the list until the name 'Ursula Benni'\n",
        "while 'Ursula Benni' in g:\n",
        "    g.pop()\n",
        "print(g)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M8fxzWuSSjhT",
        "outputId": "8ca2fecc-2b0d-4274-ec56-bca0b1afef4c"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Ursula Benni', 'Primo Nino', 'Nicola 2Van', 'Nack Irner', 'Carlos De Mayo']\n",
            "[]\n",
            "['Carlos De Mayo']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Enumerate list example\n",
        "\n",
        "iter_example = ['Primo Nino', 'Nicola 2Van', 'Nack Irner', 'Ursula Benni', 'Frederick Austerlitz']\n",
        "#print(enumerate(iter_example)) #<enumerate object at 0x7fd35723c640>\n",
        "\n",
        "for idx, val in enumerate(iter_example):\n",
        "   print(idx,\" \", val) \n",
        "\n",
        "print(\"\\n---\")\n",
        "\n",
        "for idx, val in enumerate(iter_example,3): \n",
        "   print(idx,\" \", val) \n",
        "# Note : \n",
        "#list structure is not affected   \n",
        "#print(\"\\n\",iter_example[3]) # Note : list structure is not affected\n",
        "\n",
        "print(\"\\n---\")\n",
        "\n",
        "#Note \n",
        "#Be careful to use in the loop of enumerated changes on the list such as pop (), del () or remove ():\n",
        "for idx, val in enumerate(iter_example): # ok!\n",
        "   if val == 'Ursula Benni':\n",
        "     iter_example[idx] = '$'\n",
        "print(iter_example)  \n",
        "\n",
        "print(\"\\n---\")\n",
        "\n",
        "for i,v in enumerate(iter_example): # Be care!\n",
        "     print(i,\" \",v)\n",
        "     iter_example.pop(1)\n",
        "print(iter_example) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KT9SCjjLSzkq",
        "outputId": "567512ff-411e-4d6c-9bd7-9be36e8426df"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0   Primo Nino\n",
            "1   Nicola 2Van\n",
            "2   Nack Irner\n",
            "3   Ursula Benni\n",
            "4   Frederick Austerlitz\n",
            "\n",
            "---\n",
            "3   Primo Nino\n",
            "4   Nicola 2Van\n",
            "5   Nack Irner\n",
            "6   Ursula Benni\n",
            "7   Frederick Austerlitz\n",
            "\n",
            "---\n",
            "['Primo Nino', 'Nicola 2Van', 'Nack Irner', '$', 'Frederick Austerlitz']\n",
            "\n",
            "---\n",
            "0   Primo Nino\n",
            "1   Nack Irner\n",
            "2   Frederick Austerlitz\n",
            "['Primo Nino', 'Frederick Austerlitz']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# List comprehension \n",
        "#Syntax: [ output_expression - for (set value to iterate) - if (conditonal filter)] \n",
        "numbers = [x**3 for x in range(1,10+1)]\n",
        "print(numbers) # [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n",
        "\n",
        "result = [n+7 for n in numbers if n % 2 == 0]\n",
        "print(result) # [15, 71, 223, 519, 1007]\n",
        "\n",
        "# Nested list - possible combinations\n",
        "pair1 = [(j, k) for j in (\"a\" ,\"b\", \" c\") for k in (\"1\",\"2\")]   \n",
        "print(pair1) #[('a', '1'), ('a', '2'), ('b', '1'), ('b', '2'), (' c', '1'), (' c', '2')]\n",
        "\n",
        "# Nested list to Flatten list : using comprehension\n",
        "mylist = [[1, 2, 3], [\"%\", \"$\", \"@\"], [\"A\", \"B\"]]\n",
        "ft = [i for sub in mylist for i in sub] \n",
        "print(ft) #[1, 2, 3, '%', '$', '@', 'A', 'B']"
      ],
      "metadata": {
        "id": "1mFZN-igTj0O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Given a filename (string) as input, this function returns a set of all words in which one of five vowels can be found.\n",
        "def fwv(file_name):\n",
        "     vowels = {'a', 'e', 'i', 'o', 'u'}\n",
        "     file1 = open(file_name,\"r\") \n",
        "     p = file1.read()\n",
        "\n",
        "     k = [j for j in p.split() for i in j if i in vowels] \n",
        "     k= list(set(k)) #to remove duplicated from list \n",
        "     return k"
      ],
      "metadata": {
        "id": "CNWmYvZHT6Zr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dictionary : collection of key-value pairs."
      ],
      "metadata": {
        "id": "UdM4x6q4T887"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = {\"Finland\": 652, \"Taiwan\": 99099, \"Japan\": 41894,\"Brazil\": 35542}\n",
        "print(len(d)) # 4\n",
        "\n",
        "print(d[\"Japan\"]) # 41894\n",
        "print(d.get(\"Japan\"))  # 41894\n",
        "\n",
        "print('Finland' in d) # True\n",
        "print(652 in d) # False\n",
        "print(652 in d.values()) # True\n",
        "\n",
        "print(d.items())  # dict_items([('Finland', 652), ('Taiwan', 99099), ('Japan', 41894), ('Brazil', 35542)])\n",
        "print(d.keys())  # dict_keys(['Finland', 'Taiwan', 'Japan', 'Brazil'])\n",
        "print(d.values())  # dict_values([652, 99099, 41894, 35542])"
      ],
      "metadata": {
        "id": "Rn0Sg2r8UAvZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Iteration with d.items() d.keys() d.values() \n",
        "for naz, num in d.items():\n",
        "    #print(type(num),type(naz) ) #<class 'int'> <class 'str'>\n",
        "    print(f\"{naz.title()} lost {num / 100} €.\")\n",
        "\n",
        "for n in d.keys():\n",
        "    print(f\" - {n.title()}\")  \n",
        "\n",
        "for n in d.values():\n",
        "    print(f\"\\t* {n}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E7vO1yyCUNhh",
        "outputId": "a77708cd-b363-47ed-9e8b-7ff6e8df0392"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Finland lost 6.52 €.\n",
            "Taiwan lost 990.99 €.\n",
            "Japan lost 418.94 €.\n",
            "Brazil lost 355.42 €.\n",
            " - Finland\n",
            " - Taiwan\n",
            " - Japan\n",
            " - Brazil\n",
            "\t* 652\n",
            "\t* 99099\n",
            "\t* 41894\n",
            "\t* 35542\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Cast d.keys() d.values() in a list\n",
        "dll = list(d.keys()) \n",
        "print(dll) \n",
        "dnl = list(d.values())\n",
        "print(dnl) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AyxXQ_gEUXlQ",
        "outputId": "ebe170a1-6488-4069-aede-fc1004a58ca8"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Finland', 'Taiwan', 'Japan', 'Brazil']\n",
            "[652, 99099, 41894, 35542]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Delete a key-value pair in dictionary\n",
        "del d[\"Japan\"] # out {'Finland': 652, 'Taiwan': 99099, 'Brazil': 35542} "
      ],
      "metadata": {
        "id": "nt36QD11UbW-"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Merge  of dictionary           \n",
        "d = {\"Finland\": 652, \"Taiwan\": 99099, \"Japan\": 41894,\"Brazil\": 35542}\n",
        "d1 = {'a':1, 'b':2, 'c':3}\n",
        "all_keys = d1.keys() | d.keys() # NOTE : | Bitwise Or\n",
        "print(\"All keys: \",all_keys,\"\\n\") \n",
        "d_merge = {}\n",
        "for key in all_keys:\n",
        "      d_merge[key] = [d.get(key), d1.get(key)] \n",
        "print(d_merge)    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "klREBcrLUenQ",
        "outputId": "2baedd7d-9980-4e6b-91ad-6b0631326c2e"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All keys:  {'b', 'a', 'Finland', 'c', 'Taiwan', 'Brazil', 'Japan'} \n",
            "\n",
            "{'b': [None, 2], 'a': [None, 1], 'Finland': [652, None], 'c': [None, 3], 'Taiwan': [99099, None], 'Brazil': [35542, None], 'Japan': [41894, None]}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Manipulate dictionary \n",
        "print(d_merge) \n",
        "d_merge['Cambogia'] = d_merge.pop('a') # delete pair key-value in dictionary and put its content(the  value) \n",
        "# at the end with a new name\n",
        "print(d_merge,\"\\n\") \n",
        "\n",
        "d_merge['Taiwan'] = 900094  # New value in key 'Taiwan'\n",
        "del d_merge['b']  # delete an Key-Value Pair 'b'\n",
        "d_merge['e'] = 4  #add New Key-Value Pair To Dictionary \n",
        "print(d_merge,\"\\n\")\n",
        "\n",
        "d_merge.clear()#The clear() method removes all items from the dictionary.\n",
        "print(d_merge) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SNg834wAUy_j",
        "outputId": "e36942f5-ced9-4341-c304-769486235225"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'b': [None, 2], 'a': [None, 1], 'Finland': [652, None], 'c': [None, 3], 'Taiwan': [99099, None], 'Brazil': [35542, None], 'Japan': [41894, None]}\n",
            "{'b': [None, 2], 'Finland': [652, None], 'c': [None, 3], 'Taiwan': [99099, None], 'Brazil': [35542, None], 'Japan': [41894, None], 'Cambogia': [None, 1]} \n",
            "\n",
            "{'Finland': [652, None], 'c': [None, 3], 'Taiwan': 900094, 'Brazil': [35542, None], 'Japan': [41894, None], 'Cambogia': [None, 1], 'e': 4} \n",
            "\n",
            "{}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Flipped dict : The output dict's keys are the input dict's values, and vice versa\n",
        "drio = {'a':1, 'b':2, 'c':\"!\", 'd':4}\n",
        "flip_drio = {v: k for k,v in drio.items() }    \n",
        "print(flip_drio)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m_f90mBlUvBu",
        "outputId": "d2f09061-c04e-46b4-fac5-ba80581d552f"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 'a', 2: 'b', '!': 'c', 4: 'd'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Dictionary of dictionary\n",
        "# Create a dictionary of  dictionary\n",
        "from operator import itemgetter\n",
        "\n",
        "def name():\n",
        "  n = random.choice(['François Truffaut', 'Abdul ah Ciabat ','Pinò ou Poisson','Richard the Lionheart','Yes Wecan'])\n",
        "  k = random.choice('123456879')\n",
        "  k1 = random.choice('§M¼A&çKLGY%')\n",
        "  return n + \" \"+ k + k1\n",
        "\n",
        "def place():\n",
        "  p = random.choice([\"France\",\"Taiwan\",\"Japan\",\"Romania\",\"Canada\"])\n",
        "  return p \n",
        "\n",
        "d = {}\n",
        "c = 1\n",
        "while c < 5 :\n",
        "  n = name()\n",
        "  d[n] = {} # key ->  n : value ->  dict {}\n",
        "  #Adding items in a Sub-Dictionary\n",
        "  d[n]['Birth place'] = place()\n",
        "  d[n]['Birth weight'] = random.randint(12, 36)\n",
        "  c +=1\n",
        "\n",
        "print(d,\"\\n\")\n",
        "\n",
        "for i,v in d.items():\n",
        "      print(i) # name\n",
        "      for j,k in v.items(): # sub-dictionary\n",
        "           print(\"\\t\",\" \",j,\" : \",k)\n",
        "\n",
        "s = 0 \n",
        "for i in (d):\n",
        "  s = s + (d[i]['Birth weight'])\n",
        "print(\"\\n Sum of total weights\",s)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4vWkhgoLVI1F",
        "outputId": "0741c3ff-f60a-413b-f159-bce8c832ce42"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Richard the Lionheart 8A': {'Birth place': 'Taiwan', 'Birth weight': 34}, 'Pinò ou Poisson 6&': {'Birth place': 'Japan', 'Birth weight': 28}, 'Richard the Lionheart 4K': {'Birth place': 'Romania', 'Birth weight': 24}, 'Abdul ah Ciabat  4K': {'Birth place': 'Canada', 'Birth weight': 27}} \n",
            "\n",
            "Richard the Lionheart 8A\n",
            "\t   Birth place  :  Taiwan\n",
            "\t   Birth weight  :  34\n",
            "Pinò ou Poisson 6&\n",
            "\t   Birth place  :  Japan\n",
            "\t   Birth weight  :  28\n",
            "Richard the Lionheart 4K\n",
            "\t   Birth place  :  Romania\n",
            "\t   Birth weight  :  24\n",
            "Abdul ah Ciabat  4K\n",
            "\t   Birth place  :  Canada\n",
            "\t   Birth weight  :  27\n",
            "\n",
            " Sum of total weights 113\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Sort a dictionary:   \n",
        "ld1 = sorted(d.items())      \n",
        "print(ld1,\"\\n\")\n",
        "\n",
        "ld2 = sorted(d.values(), key=itemgetter('Birth weight'))  \n",
        "print(ld2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O069ZSquVZ9e",
        "outputId": "d949ab23-5e03-4b8e-a2de-fb2ef1d73dae"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('Abdul ah Ciabat  4K', {'Birth place': 'Canada', 'Birth weight': 27}), ('Pinò ou Poisson 6&', {'Birth place': 'Japan', 'Birth weight': 28}), ('Richard the Lionheart 4K', {'Birth place': 'Romania', 'Birth weight': 24}), ('Richard the Lionheart 8A', {'Birth place': 'Taiwan', 'Birth weight': 34})] \n",
            "\n",
            "[{'Birth place': 'Romania', 'Birth weight': 24}, {'Birth place': 'Canada', 'Birth weight': 27}, {'Birth place': 'Japan', 'Birth weight': 28}, {'Birth place': 'Taiwan', 'Birth weight': 34}]\n"
          ]
        }
      ]
    }
  ]
}