{"id":5818,"date":"2022-04-02T15:06:59","date_gmt":"2022-04-02T13:06:59","guid":{"rendered":"http:\/\/miro.borodziuk.eu\/?p=5818"},"modified":"2026-01-24T13:50:24","modified_gmt":"2026-01-24T12:50:24","slug":"dictionaries-in-python","status":"publish","type":"post","link":"http:\/\/miro.borodziuk.eu\/index.php\/2022\/04\/02\/dictionaries-in-python\/","title":{"rendered":"Dictionaries in Python"},"content":{"rendered":"

1. Dictionaries are unordered*<\/strong>, changeable (mutable), and indexed collections of data. (*<\/strong>In Python 3.6x dictionaries have become ordered by default.<\/p>\n

<\/p>\n

Each dictionary is a set of key: value<\/i> pairs. You can create it by using the following syntax:<\/p>\n

\n
\n
my_dictionary = {\r\n  key1: value1,\r\n  key2: value2,\r\n  key3: value3,\r\n}<\/pre>\n
 <\/p>\n
2. If you want to access a dictionary item, you can do so by making a reference to its key inside a pair of square brackets (ex. 1) or by using the get()<\/code> method (ex. 2):<\/p>\n<\/div>\n<\/div>\n
\n
\n
pol_eng = {\r\n  \"kwiat\": \"flower\",\r\n  \"woda\": \"water\",\r\n  \"gleba\": \"soil\"\r\n  }\r\n\r\nitem_1 = pol_eng[\"gleba\"] # ex. 1\r\nprint(item_1) # outputs: soil\r\n\r\nitem_2 = pol_eng.get(\"woda\")\r\nprint(item_2) # outputs: water<\/pre>\n
 <\/p>\n
3. If you want to change the value associated with a specific key, you can do so by referring to the item’s key name in the following way:<\/div>\n<\/div>\n<\/div>\n
\n
\n
pol_eng = {\r\n  \"zamek\": \"castle\",\r\n  \"woda\": \"water\",\r\n  \"gleba\": \"soil\"\r\n  }\r\n\r\npol_eng[\"zamek\"] = \"lock\"\r\nitem = pol_eng[\"zamek\"]\r\nprint(item) # outputs: lock<\/pre>\n<\/div>\n<\/div>\n
 <\/p>\n
4. To add or remove a key (and the associated value), use the following syntax:<\/p>\n
\n
\n
phonebook = {} # an empty dictionary\r\n\r\nphonebook[\"Adam\"] = 3456783958 # create\/add a key-value pair\r\nprint(phonebook) # outputs: {'Adam': 3456783958}\r\n\r\ndel phonebook[\"Adam\"]\r\nprint(phonebook) # outputs: {}<\/pre>\n
You can also insert an item to a dictionary by using the update()<\/code> method, and remove the last element by using the popitem()<\/code> method, e.g.:<\/p>\n<\/div>\n<\/div>\n
\n
\n
pol_eng = {\"kwiat\": \"flower\"}\r\n\r\npol_eng.update({\"gleba\": \"soil\"})\r\nprint(pol_eng) # outputs: {'kwiat': 'flower', 'gleba': 'soil'}\r\n\r\npol_eng.popitem()\r\nprint(pol_eng) # outputs: {'kwiat': 'flower'}<\/pre>\n
 <\/p>\n
5. Loop through a keys of the dictionary, e.g.:<\/p>\n<\/div>\n<\/div>\n
\n
\n
pol_eng = {\r\n  \"zamek\": \"castle\",\r\n  \"woda\": \"water\",\r\n  \"gleba\": \"soil\"\r\n  }\r\n\r\nfor k in pol_eng:\r\n  print(k)\r\n\r\n<\/pre>\n
zamek<\/code>
\nwoda<\/code>
\ngleba<\/code><\/p>\n
or<\/p>\n<\/div>\n<\/div>\n
\n
pol_eng = { \r\n    \"zamek\": \"castle\", \r\n    \"woda\": \"water\", \r\n    \"gleba\": \"soil\" } \r\n\r\nfor k in pol_eng.keys(): \r\n    print(k)<\/pre>\n
zamek<\/code>
\nwoda<\/code>
\ngleba<\/code><\/p>\n<\/div>\n
7.\u00a0 Loop through a dictionary’s values<\/p>\n
pol_eng = { \r\n    \"zamek\": \"castle\", \r\n    \"woda\": \"water\", \r\n    \"gleba\": \"soil\" } \r\n\r\nfor v in pol_eng.values(): \r\n    print(v)<\/pre>\n
castle<\/code>
\nwater<\/code>
\nsoli<\/code><\/p>\n
or<\/p>\n
pol_eng = { \r\n    \"zamek\": \"castle\", \r\n    \"woda\": \"water\", \r\n    \"gleba\": \"soil\" } \r\n\r\nfor i in pol_eng.keys():\r\n    print(pol_eng[i])\r\n<\/pre>\n
castle<\/code>
\nwater<\/code>
\nsoli<\/code><\/p>\n
 <\/p>\n
6. If you want to loop through a dictionary’s keys and values, you can use the items()<\/code> method, e.g.:<\/p>\n
pol_eng = {\r\n  \"zamek\": \"castle\",\r\n  \"woda\": \"water\",\r\n  \"gleba\": \"soil\"\r\n  }\r\n \r\nfor value in pol_eng.items():\r\n  print(value)<\/pre>\n
('zamek', 'castle') <\/code>
\n('woda', 'water') <\/code>
\n('gleba', 'soil')<\/code><\/p>\n
or<\/p>\n
\n
\n
pol_eng = {\r\n  \"zamek\": \"castle\",\r\n  \"woda\": \"water\",\r\n  \"gleba\": \"soil\"\r\n  }\r\n\r\nfor k, v in pol_eng.items():\r\n  print(k, \":\", v)<\/pre>\n
\n
\n
zamek : castle <\/code>
\nwoda : water <\/code>
\ngleba : soil<\/code><\/p>\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
8. To check if a given key exists in a dictionary, you can use the in<\/code> keyword:<\/p>\n<\/div>\n<\/div>\n
\n
\n
pol_eng = {\r\n  \"zamek\": \"castle\",\r\n  \"woda\": \"water\",\r\n  \"gleba\": \"soil\"\r\n  }\r\n\r\nif \"zamek\" in pol_eng:\r\n  print(\"Yes\")\r\nelse:\r\n  print(\"No\")<\/pre>\n
<\/div>\n<\/div>\n<\/div>\n
 <\/p>\n
9. You can use the del<\/code> keyword to remove a specific item, or delete a dictionary. To remove all the dictionary’s items, you need to use the clear()<\/code> method:<\/p>\n
\n
\n
pol_eng = {\r\n  \"zamek\": \"castle\",\r\n  \"woda\": \"water\",\r\n  \"gleba\": \"soil\"\r\n  }\r\n\r\nprint(len(pol_eng)) # outputs: 3\r\ndel pol_eng[\"zamek\"] # remove an item\r\nprint(len(pol_eng)) # outputs: 2\r\n\r\npol_eng.clear() # removes all the items\r\nprint(len(pol_eng)) # outputs: 0\r\n\r\ndel pol_eng # removes the dictionary<\/pre>\n
 <\/p>\n
10. To copy a dictionary, use the copy()<\/code> method:<\/p>\n<\/div>\n<\/div>\n
\n
\n
pol_eng = {\r\n  \"zamek\": \"castle\",\r\n  \"woda\": \"water\",\r\n  \"gleba\": \"soil\"\r\n  }\r\n\r\ncopy_dictionary = pol_eng.copy()<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
 <\/p>\n
Exercise 1<\/strong><\/p>\n
Write a program that will “glue” the two dictionaries (d1<\/code> and d2<\/code>) together and create a new one (d3<\/code>).<\/p>\n
d1 = {'Adam Smith': 'A', 'Judy Paxton': 'B+'} \r\nd2 = {'Mary Louis': 'A', 'Patrick White': 'C'} \r\nd3 = {} \r\n\r\nfor item in (d1, d2): \r\n  # Write your code here. print(d3)<\/pre>\n
<\/div>\n
\n
Sample solution:<\/p>\n
d1 = {'Adam Smith': 'A', 'Judy Paxton': 'B+'} \r\nd2 = {'Mary Louis': 'A', 'Patrick White': 'C'} \r\nd3 = {} \r\n\r\nfor item in (d1, d2): \r\n  d3.update(item) \r\n\r\nprint(d3)<\/pre>\n
 <\/p>\n
Exercise 2<\/strong><\/p>\n<\/div>\n
\n
Write a program that will convert the my_list<\/code> list to a tuple.<\/p>\n
my_list = [\"car\", \"Ford\", \"flower\", \"Tulip\"] \r\nt = # Write your code here. \r\n\r\nprint(t)<\/pre>\n
Sample solution:<\/p>\n<\/div>\n
my_list = [\"car\", \"Ford\", \"flower\", \"Tulip\"] \r\nt = tuple(my_list) \r\n\r\nprint(t)<\/pre>\n
 <\/p>\n
Exercise 3<\/strong><\/p>\n
Write a program that will convert the colors<\/code> tuple to a dictionary.<\/p>\n
colors = ((\"green\", \"#008000\"), (\"blue\", \"#0000FF\")) \r\n# Write your code here. \r\n\r\nprint(colors_dictionary)<\/pre>\n
Sample solution:<\/p>\n
colors = ((\"green\", \"#008000\"), (\"blue\", \"#0000FF\")) \r\ncolors_dictionary = dict(colors) \r\n\r\nprint(colors_dictionary)<\/pre>\n
 <\/p>\n
Exercise 4<\/strong><\/p>\n
What will happen when you run the following code?<\/p>\n
my_dictionary = {\"A\": 1, \"B\": 2} \r\ncopy_my_dictionary = my_dictionary.copy() \r\n\r\nmy_dictionary.clear() \r\nprint(copy_my_dictionary)<\/pre>\n
 <\/p>\n
The program will print {'A': 1, 'B': 2}<\/code> to the screen.<\/p>\n
 <\/p>\n
Exercise 5<\/strong><\/p>\n
What is the output of the following program?<\/p>\n
colors = { \r\n  \"white\": (255, 255, 255), \r\n  \"grey\": (128, 128, 128), \r\n  \"red\": (255, 0, 0), \r\n  \"green\": (0, 128, 0) \r\n  } \r\n\r\nfor col, rgb in colors.items(): \r\n  print(col, \":\", rgb)<\/pre>\n
 <\/p>\n
white : (255, 255, 255)<\/p>\n
grey : (128, 128, 128)<\/p>\n
red : (255, 0, 0)<\/p>\n
green : (0, 128, 0)<\/p>\n
 <\/p>\n
Ex. 6<\/p>\n
\n
\n
\n
What is the output of the following code snippet?<\/p>\n<\/div>\n<\/div>\n<\/div>\n
d = {'c': 3, 'a': 1, 'a': 5, 'a': 2}\r\nprint(d['a'])\r\n<\/pre>\n
\n
\n
\n
\n
\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
Correct answer<\/span><\/div>\n
\n
\n
2<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
\n
    \n
  • Dictionaries do not allow multiple elements with the same key. However, Python doesn’t raise an exception but stores in the dictionary only the last<\/strong> element<\/strong> among those with equal key<\/strong>:d = {'c': 3, 'a': 1, 'a': 5, 'a': 2}<\/strong><\/code> -><\/strong> d = {'c': 3, 'a': 2}<\/strong><\/code>.print(d['a'])<\/strong><\/code> -><\/strong> 2<\/strong><\/code> .<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    <\/div>\n
    <\/div>\n
    Ex. 7<\/div>\n
    \n
    \n
    \n
    \n
    Which of the following statements correctly<\/strong> creates a list<\/strong>?<\/p>\n
    (Select two answers)<\/p>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    \n
    lst3 = list('a', 'b')<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    lst2 = 1, 2, 3<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    lst4 = list(('a', 'b'))<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    lst1 = [1, 2, 2, '3', [4, 5]]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    <\/div>\n
    <\/div>\n
    \n
    \n
    \n
    \n
    \n
    \n
    Correct selection<\/span><\/div>\n
    \n
    \n
    lst4 = list(('a', 'b'))<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    lst1 = [1, 2, 2, '3', [4, 5]]<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    Try the code in your favorite Python IDE<\/strong><\/p>\n
    \n
    lst1 = [1, 2, 2, '3', [4, 5]]\r\nlst2 = 1, 2, 3\r\n# lst3 = list('a', 'b') # TypeError\r\nlst4 = list(('a', 'b'))\r\nprint(lst1)\r\nprint(lst2)\r\nprint(lst4)<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
      \n
    • The statement lst1 = [1, 2, 2, '3', [4, 5]]<\/strong><\/code> correctly<\/strong> creates the list lst1<\/strong><\/code>, with elements of various types (even duplicates) enclosed in square brackets.<\/li>\n
    • The instruction lst2 = 1, 2, 3<\/strong><\/code> does not create a list but a tuple<\/strong>.<\/li>\n
    • lst3 = list('a', 'b')<\/strong><\/code> is incorrect<\/strong> because the list()<\/strong><\/code> function accepts at most one argument<\/strong> while it receives two<\/strong>. It raises a TypeError<\/strong><\/code> exception.<\/li>\n
    • The statement lst4 = list(('a', 'b'))<\/strong><\/code> still uses the list()<\/strong><\/code>constructor<\/strong> to create the list. In this case, however, the answer is correct<\/strong> because it only receives one argument<\/strong>, a tuple<\/strong>, which it converts to a list.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
       <\/p>\n
      Ex. 8<\/div>\n
      \n
      \n
      \n
      \n
      Given the code snippet below, what statement should you insert in place of the comment line<\/strong> to get the following output:<\/p>\n
      {1: 'one', 2: 'two', 3: 'three', 4: 'four'}<\/code>?<\/p>\n
      \n
      \n
      d1 = {1: 'one', 2: 'two'}\r\nd2 = {3: 'three', 4: 'four'}\r\n\u00a0\r\n# Insert code here\r\n\u00a0\r\nprint(d1)<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      \n
      d1 = d1 + d2<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      d1.insert(d2)<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      d1.update(d2)<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      \n
      \n
      \n
      d1.append(d2)<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
      \n
      <\/div>\n
      \n
      Correct answer<\/span><\/p>\n
      \n
      \n
      \n
      \n
      \n
      d1.update(d2)<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
        \n
      • The statement d1.update(d2)<\/strong><\/code> is the correct<\/strong> answer. The parameter of the update()<\/code><\/strong> method can be a dictionary or an iterable object with key-value <\/strong>pairs.<\/li>\n<\/ul>\n
          \n
        • All other statements are wrong<\/strong>.: dictionaries do not support the append()<\/strong><\/code> and insert()<\/strong><\/code> methods and the +<\/strong><\/code> operator.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
           <\/p>\n
          Ex. 9<\/p>\n
          \n
          \n
          \n
          Which of the following dictionaries<\/strong> are created correctly<\/strong>?<\/p>\n
          (Select two answers)<\/p>\n<\/div>\n<\/div>\n<\/div>\n
          \n
          \n
          \n
          \n
          \n
          d2 = {[1, 2]: 1, [3, 4]: 3}<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
          \n
          \n
          \n
          \n
          d4 = {'Mary': 30, 'Robert': 28}<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
          \n
          \n
          \n
          \n
          d3 = {'y': 1, 'x': 10, 'x': 100}<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
          \n
          \n
          \n
          \n
          d1 = {}<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
          <\/div>\n
          <\/div>\n
          \n
          \n
          \n
          \n
          <\/div>\n<\/div>\n<\/div>\n<\/div>\n
          \n
          \n
          Correct selection<\/span><\/div>\n
          \n
          \n
          d4 = {'Mary': 30, 'Robert': 28}<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
          \n
          \n
          Correct selection<\/span><\/div>\n
          \n
          \n
          d1 = {}<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
          \n
          \n
            \n
          • The statement d1 = {}<\/strong><\/code>\u00a0 is correct<\/strong>. It creates an empty<\/strong> dictionary.<\/li>\n<\/ul>\n
              \n
            • The statement d4 = {'Mary': 30, 'Robert': 28}<\/strong><\/code> is also ok<\/strong>. Each item is correctly composed of a key and its associated value.<\/li>\n<\/ul>\n
                \n
              • The statement d2 = {[1, 2]: 1, [3, 4]: 3}<\/strong><\/code> is wrong<\/strong>. It raises a TypeError<\/strong><\/code> exception. Lists are not allowed as dictionary keys, because they are mutable objects. Dictionary keys can only be of immutable types: integer, string, tuple, etc.<\/li>\n<\/ul>\n
                  \n
                • The statement d3 = {'y': 1, 'x': 10, 'x': 100}<\/strong><\/code> is also incorrect<\/strong>, because the key 'x'<\/strong><\/code> is duplicated. The dictionary is created, but it has only the last element among those with the duplicate key:d2 = {'y': 1, 'x': 10, 'x': 100} <\/strong><\/code>-> <\/strong>d2 = {'y': 1, 'x': 100}<\/strong><\/code>.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                   <\/p>\n
                  Ex. 10<\/p>\n
                  \n
                  \n
                  \n
                  What is the output of the following code snippet?<\/p>\n
                  d = {3: 'a', 5: 'b', 1: 'c', 7: 'd'}\r\nprint(sorted(d))<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                  \n
                  \n
                  \n
                  \n
                  \n
                  {1: 'c', 3: 'a', 5: 'b', 7: 'd'}<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                  \n
                  \n
                  \n
                  \n
                  [1, 3, 5, 7]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                  \n
                  \n
                  \n
                  \n
                  (1, 3, 5, 7)<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                  \n
                  \n
                  \n
                  \n
                  1, 3, 5, 7<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                  \n
                  <\/div>\n
                  \n
                  Correct answer<\/span><\/p>\n
                  \n
                  \n
                  \n
                  \n
                  \n
                  [1, 3, 5, 7]<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                  • The sorted()<\/strong><\/code> function returns a sorted list of an iterable object. In our example, it returns a list that contains only the keys of dictionary d<\/strong><\/code>, sorted numerically. The sorting is ascending<\/strong> by default.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                     <\/p>\n
                    Ex. 11<\/p>\n
                    \n
                    \n
                    \n
                    Consider the following dictionary:<\/p>\n
                    d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}.<\/pre>\n
                    Which of the following statements removes<\/strong> the element with the key 'c'<\/strong><\/code> from the d<\/strong><\/code> dictionary?<\/p>\n
                    (Select two answers)<\/p>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    \n
                    d.remove('c')<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    d.del('c')<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    d.pop('c')<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    del d['c']<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    \n
                    Correct selection<\/span><\/div>\n
                    \n
                    \n
                    d.pop('c')<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    del d['c']<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                    • Statements del d['c']<\/strong><\/code> and d.pop('c')<\/strong><\/code> are the correct<\/strong> answers. The del<\/strong><\/code> statement and the pop()<\/strong><\/code> method remove the element associated with the key passed as the argument.<\/li>\n
                    • Statement d.del('c')<\/strong><\/code> is wrong<\/strong> and generates a SyntaxError<\/strong><\/code> exception because del<\/strong><\/code> is not a method.<\/li>\n
                    • Statement d.remove('c')<\/strong><\/code> is not ok<\/strong>: remove()<\/strong><\/code> is not a dictionary method but a list<\/strong> method <\/strong>and it generates an AttributeError<\/strong><\/code> exception.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                       <\/p>\n
                      Ex. 12<\/p>\n
                      What is the expected output of the following snippet ?<\/p>\n
                          l={}\r\n    for i in 'Skywalker':\r\n        if i in 'Vader':\r\n           l[ord(i)]=i\r\n    else:\r\n        l[ord('d')]='d' \r\n     \r\n    for j in l.keys():\r\n        print(l[j], end=' ')<\/pre>\n
                      Explanation:<\/strong><\/p>\n
                      The l<\/code> variable is an empty dictionary initially.<\/p>\n
                      The for <\/code>loop populates the dictionary with the characters from the string ‘Skywalker” that are in the string ‘Vader’ (i.e. a, e and r) : those are the values of the dictionary while the corresponding keys are the Unicode code of the corresponding character (the ord()<\/code> function returns the Unicode code of a character).<\/p>\n
                      In a for-else<\/strong> loop, the else:<\/code> clause is executed when the code below the for<\/code> loop has completed successfully – in this case the code in the else:<\/code> clause adds the following key:value pair to the dictionary : 100:'d'<\/code>.<\/p>\n
                      So by the end of the first for-else loop, the l<\/code> dictionary is as follow:<\/p>\n
                      \n
                      \n
                      {<\/span>97<\/span>:<\/span> 'a'<\/span>,<\/span> 101<\/span>:<\/span> 'e'<\/span>,<\/span> 114<\/span>:<\/span> 'r'<\/span>,<\/span> 100<\/span>:<\/span> 'd'<\/span>}<\/span><\/code><\/p>\n<\/div>\n<\/div>\n
                      The last for <\/code>loop, simply print each value from the l<\/code> dictionary using the end <\/code>parameter of the print()<\/code> function to have the characters nicely printed on one line, separated by a space.<\/p>\n
                      Resulting output is :<\/p>\n
                      a e r d <\/code><\/p>\n
                       <\/p>\n
                      Ex. 13<\/p>\n
                      What is the output of the following snippet ?<\/p>\n
                          my_list = {'a': ord('a'), 'b': ord('b'), 'c': ord('c'), 'd': ord('d') }\r\n    list=[]\r\n    for i in sorted(my_list.keys()):\r\n        list.insert(-1,my_list[i])\r\n     \r\n    print(list)<\/pre>\n
                      \n
                      \n
                      \n
                      \n
                      \n
                      \n
                      A: [<\/span>97<\/span>,<\/span> 98<\/span>,<\/span> 99<\/span>,<\/span> 100<\/span>]<\/span><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      \n
                      \n
                      \n
                      \n
                      B: [<\/span>100<\/span>,<\/span> 99<\/span>,<\/span> 98<\/span>,<\/span> 97<\/span>]<\/span><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      \n
                      \n
                      \n
                      \n
                      C: [<\/span>98<\/span>,<\/span> 99<\/span>,<\/span> 100<\/span>,<\/span> 97<\/span>]<\/span><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      \n
                      \n
                      \n
                      \n
                      D: [<\/span>'a'<\/span>,<\/span> 'b'<\/span>,<\/span> 'c'<\/span>,<\/span> 'd'<\/span>]<\/span><\/code><\/p>\n
                      Explanation:<\/p>\n
                      my_list<\/code> is a dictionary (the poorly chosen name was selected to confuse you).<\/p>\n
                      The ord()<\/code> function returns the Unicode code from a given character. So my_list<\/code> is a dictionary that looks like this :<\/p>\n
                      \n
                      \n
                      {<\/span>'a'<\/span>:<\/span> 97<\/span>,<\/span> 'b'<\/span>:<\/span> 98<\/span>,<\/span> 'c'<\/span>:<\/span> 99<\/span>,<\/span> 'd'<\/span>:<\/span> 100<\/span>}<\/span><\/code><\/p>\n<\/div>\n<\/div>\n
                      my_list.keys()<\/code> will return a view object that displays the list of all the keys of the dictionary (in this case : dict_keys(['a', 'b', 'c', 'd')]<\/code>).<\/p>\n
                      The for <\/code>loop will iterate over each of those keys and my_list[i] <\/code>will be the value from the dictionary for the corresponding key ( for example : my_list['a'] <\/code>–> 97<\/code>). So the for <\/code>loop will simply insert each value <\/strong>from the dictionary in the list list<\/code> using the insert()<\/code> method.<\/p>\n
                      The\u00a0 insert()<\/code> method inserts a given element at a given index in a list. The syntax is :<\/p>\n
                      list_name.insert(index, element)<\/em><\/code>.<\/p>\n
                      In this case, index = -1 ; pay particular attention to the behavior of the insert()<\/code> method in this case – see print out below for details.<\/p>\n
                      Try it yourself:<\/p>\n
                          my_list = {'a': ord('a'), 'b': ord('b'), 'c': ord('c'), 'd': ord('d') }\r\n    print(my_list)\r\n    list=[]\r\n    for i in sorted(my_list.keys()):\r\n        print(my_list[i])\r\n        list.insert(-1,my_list[i])\r\n        print(list)\r\n     \r\n    print(list)\r\n     \r\n    # Following output will be printed :\r\n    #{'a': 97, 'b': 98, 'c': 99, 'd': 100}\r\n    #97\r\n    #[97]\r\n    #98\r\n    #[98, 97]\r\n    #99\r\n    #[98, 99, 97]\r\n    #100\r\n    #[98, 99, 100, 97]\r\n    #[98, 99, 100, 97]<\/pre>\n
                      C.<\/p>\n<\/div>\n
                       <\/p>\n
                      Ex. 14<\/p>\n
                      What code would you insert instead of the comment to obtain the expected output ?<\/p>\n
                      Expected output :<\/em><\/p>\n<\/div>\n<\/div>\n
                          Luke\r\n    Han\r\n    Leia<\/pre>\n
                      Code :<\/em><\/p>\n
                          my_dict = {}\r\n    my_list = ['Luke', 'Han', 'Leia', 'Ben']\r\n     \r\n    for i in range(len(my_list)-1):\r\n        my_dict[i] = (my_list[i], )\r\n     \r\n    for i in sorted(my_dict.keys()):\r\n        j = my_dict[i]\r\n        # Insert your code here<\/pre>\n
                      A. <\/span>print(j[0])<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      B. <\/span>print(j)<\/code><\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      \n
                      \n
                      C. print(j[i])<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      \n
                      \n
                      D. print(j['0'])<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      \n
                       <\/p>\n
                      Explanation:<\/em><\/p>\n
                      The code mixes lists, tuples and dictionaries.<\/p>\n
                      The first for<\/code> loop will update the initially empty dictionary my_dict <\/code>as follow:<\/p>\n
                      \n
                      \n
                      {<\/span>0<\/span>:<\/span> (<\/span>'Luke'<\/span>,),<\/span> 1<\/span>:<\/span> (<\/span>'Han'<\/span>,),<\/span> 2<\/span>:<\/span> (<\/span>'Leia'<\/span>,)}<\/span><\/code><\/p>\n<\/div>\n<\/div>\n
                      my_dict <\/code>is a dictionary with keys being integer 0<\/code>, 1<\/code>, 2<\/code> and corresponding values are tuples : <\/strong>('Luke',)<\/code> , ('Han',)<\/code>, ('Leia',)<\/code>.<\/p>\n
                      The second for\u00a0 <\/code>loop will assign variable j<\/code> with the values of the dictionary, which are tuples<\/strong>. So j<\/code> is a tuple too.<\/p>\n
                      To print the expected output, you need to access the first item from the tuple , – i.e. j[0]<\/code><\/p>\n
                      Try it yourself:<\/p>\n
                          my_dict = {}\r\n    my_list = ['Luke', 'Han', 'Leia', 'Ben']\r\n     \r\n    for i in range(len(my_list)-1):\r\n        my_dict[i] = (my_list[i], )\r\n     \r\n    print(my_dict)     # {0: ('Luke',), 1: ('Han',), 2: ('Leia',)}\r\n     \r\n    for i in sorted(my_dict.keys()):\r\n        j = my_dict[i]\r\n        print(j[0])    # Luke -> Han -> Leia\r\n        #print(j[i])   # Luke -> exception : IndexError: tuple index out of range\r\n        #print(j)      # ('Luke',) -> ('Han',) -> ('Leia',)\r\n        #print(j['0']) # exception : TypeError: tuple indices must be integers or slices, not str<\/pre>\n
                       <\/p>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
                      1. Dictionaries are unordered*, changeable (mutable), and indexed collections of data. (*In Python 3.6x dictionaries have become ordered by default.<\/p>\n","protected":false},"author":2,"featured_media":5819,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[100],"tags":[],"_links":{"self":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5818"}],"collection":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/comments?post=5818"}],"version-history":[{"count":21,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5818\/revisions"}],"predecessor-version":[{"id":6290,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5818\/revisions\/6290"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media\/5819"}],"wp:attachment":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media?parent=5818"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/categories?post=5818"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/tags?post=5818"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}