{"id":28032,"date":"2023-08-24T19:48:45","date_gmt":"2023-08-24T14:18:45","guid":{"rendered":"https:\/\/tocxten.com\/?page_id=28032"},"modified":"2023-08-24T21:34:01","modified_gmt":"2023-08-24T16:04:01","slug":"dictionaries","status":"publish","type":"page","link":"https:\/\/tocxten.com\/index.php\/dictionaries\/","title":{"rendered":"Dictionaries"},"content":{"rendered":"\n

Topics Covered <\/strong>: The Dictionary Data Type, Pretty Printing, Using Data Structures to Model Real-World Things<\/p>\n\n\n\n

A dictionary is a collection of items that are unordered, changeable, and indexed<\/strong>. Dictionary items are made up of Key \u2013 Value pair<\/strong> and each key is separated from its value by a colon (: )<\/strong> and whole thing is enclosed in curly braces as illustrated in the following syntax:<\/p>\n\n\n\n

Syntax<\/strong>: my_dict = {‘key1’: ‘value1′,’key2’: ‘value2′,’key3′: value3’\u2026’keyn’: ‘valuen’}<\/p>\n\n\n\n

Example: <\/strong><\/p>\n\n\n\n

my_dict = { \r\n    \"brand\":\"Maruthi\",\r\n    \"Model\": \"Suzuki\",\r\n    \"Year\":2023\r\n}   \r\nprint(my_dict)\r\n#Output : \r\n{'brand': 'Maruthi', 'Model': 'Suzuki', 'Year': 2023}\r\n<\/code><\/pre>\n\n\n\n
Keys are unique<\/strong> within a dictionary while values may not be. The values of a dictionary can be of any type, but the keys must be of an immutable<\/strong> data type such as strings, numbers, or tuples. A dictionary is an extremely useful data storage construct for storing and retrieving all key value pairs, where each element is accessed (or indexed) by a unique key. However, dictionary keys are not in sequences and hence maintain no left-to right order.<\/p>\n\n\n\n
Dictionary is a mapping between a set of indices (called\u00a0keys)<\/strong>\u00a0and a set of\u00a0values<\/strong>. Each key maps a value. The association of a key and a value is called a key-value<\/strong> pair.<\/p>\n\n\n\n
Creating Dictionaries:<\/strong><\/strong><\/p>\n\n\n\n
Creating Empty Dictionary:<\/strong> Empty dictionaries can be created using curly braces and dict() function as illustrated below: <\/p>\n\n\n\n
# Creating Empty Dictionaries \r\ned1 = {}  # using curly braces\r\ned2 = dict() # using dict() function\r\nprint(ed1)\r\nprint(ed2)\r\n#Output<\/strong>:\r\n{}\r\n{}\r\n<\/code><\/pre>\n\n\n\n
Creating<\/strong>\u00a0Dictionary with Multiple Elements: <\/strong><\/p>\n\n\n\n
Dictionaries with multiple elements can be created using curly braces. Each element containing key value pair are separated by comma operator as illustrated below: <\/strong><\/p>\n\n\n\n
Example 1:<\/strong><\/p>\n\n\n\n
# Creating dictionary with multiple elements \r\ndict1 <\/strong>= {\"Name\":\"Palguni\",\"USN\":\"4MCECSBS123\",\"Course\":  \"BE\",\"Branch\":\"CSBS\",\"SEM\":\"1\"}\r\nprint(dict1<\/strong>)\r\n\r\n#Output:<\/strong>\r\n{'Name': 'Palguni', 'USN': '4MCECSBS123', 'Course': 'BE', 'Branch': 'CSBS', 'SEM': '1'}\n\n<\/code><\/pre>\n\n\n\n
Example 2 :<\/strong> <\/p>\n\n\n\n
H=dict()\r\nH[\"one\"]=\"keyboard\" \r\nH[\"two\"]=\"Mouse\" \r\nH[\"three\"]=\"printer\" \r\nH[\"Four\"]=\"scanner\" \r\nprint(H)\r\n\r\n#Output:<\/strong>\r\n\r\n{'one': 'keyboard', 'two': 'Mouse', 'three': 'printer', 'Four': 'scanner'}\r\n<\/code><\/pre>\n\n\n\n
Accessing Values in Dictionary<\/strong><\/p>\n\n\n\n
To access dictionary elements, you can use the familiar square brackets along with the key to obtain its value. Following is a simple example:<\/p>\n\n\n\n
student = {\"Name\":\"Palguni\",\"USN\":\"4MCECSBS123\",\"Course\": \"BE\",\"Branch\":\"CSBS\",\"SEM\":\"1\"}\r\nprint(student[\"Name\"])\r\nprint(student[\"USN\"])\r\nprint(student[\"Course\"])\r\nprint(student[\"Branch\"])\r\nprint(student[\"SEM\"])\r\n\r\n#Output <\/strong>\r\n\r\nPalguni\r\n4MCECSBS123\r\nBE\r\nCSBS\r\n1<\/code><\/pre>\n\n\n\n
If we attempt to access a data item with a key, which is not part of the dictionary, we get an error as follows \u2013<\/p>\n\n\n\n
print(student[\"Age\"])\r\n# Output:\r\nKeyError: 'Age'\r\n<\/code><\/pre>\n\n\n\n
Updating Dictionary<\/strong> <\/p>\n\n\n\n
Dictionary can be updated by adding a new entry or a key-value pair, modifying an existing entry, or deleting an existing entry<\/em> as shown below in the simple example:<\/p>\n\n\n\n
student = {\"Name\":\"Raju\",\"Class\":8}\r\nprint(student)\r\n#Output:\r\n{'Name': 'Raju', 'Class': 8}\r\n\r\nstudent[\"Age\"] = 10\r\nstudent[\"School\"] = \"Contextual International School\"\r\nprint(student)\r\n#Output:\r\n{'Name': 'Raju', 'Class': 8, 'Age': 10, 'School': 'Contextual International School'}\r\n<\/code><\/pre>\n\n\n\n
Deleting Dictionary Elements<\/strong><\/p>\n\n\n\n
You can either remove individual dictionary elements or clear the entire contents of a dictionary.<\/p>\n\n\n\n
Consider a dictionary dictx<\/strong> as illustrated below:<\/p>\n\n\n\n
dictx = {'Name': 'Pala', 'Age': 7, 'Class': 'First'}\r\nprint(dictx)\r\n#Output: {'Name': 'Pala', 'Age': 7, 'Class': 'First'}\r\n<\/code><\/pre>\n\n\n\n
Following example illustrates the deletion of single element with key \u2018Name<\/strong>\u2019:<\/p>\n\n\n\n
del dictx['Name']; # remove entry with key 'Name'\r\nprint(dictx)\r\n#Output: {'Age': 7, 'Class': 'First'}\r\n<\/code><\/pre>\n\n\n\n
The clear()<\/strong> method can be used to delete all the elements of dictionary as illustrated below:<\/p>\n\n\n\n
dictx.clear()    # remove all entries in dict\r\nprint(dictx)\r\n#Output: {}\r\n<\/code><\/pre>\n\n\n\n
One can also delete the entire dictionary in a single operation. To explicitly remove an entire dictionary, just use the\u00a0del<\/strong>\u00a0statement. Following is a simple example \u2013<\/p>\n\n\n\n
del dictx        # delete entire dictionary\r\nprint(dictx)\r\n#Output: NameError: name 'dictx' is not defined\r\n<\/code><\/pre>\n\n\n\n
Properties of Dictionary Keys<\/strong><\/p>\n\n\n\n
Dictionary values<\/strong> have no restrictions, and they can be of any arbitrary object. Keys are immutable<\/strong> type with following properties:<\/p>\n\n\n\n
    \n
  1. More than one entry per key is not allowed. When duplicate key is allowed the last assignment wins:<\/strong>    <\/li>\n<\/ol>\n\n\n\n
         dictX = {'Name':\"Raju\",'Age':16,\"Name\":\"Rahul\"}\n     print(dictX)\n     #Output:<\/strong> {'Name': 'Rahul', 'Age': 16}\n<\/code><\/pre>\n\n\n\n
    2. Since keys are immutable, one can use strings , numbers, or tuples as <\/strong>       dictionary keys.<\/strong><\/p>\n\n\n\n
    <\/p>\n\n\n\n
    Python Dictionary items() method<\/strong><\/p>\n\n\n\n
    It returns the content of dictionary as a list of key and value. The key and value pair
    will be in the form of a tuple, which is not in any order.<\/p>\n\n\n\n
    Syntax:<\/strong> dictionary. items()<\/p>\n\n\n\n
    D={'1':'Sunday','1':'Monday','3':'Tuesday','4':'Wednesday'} \r\nD.keys()\r\n#Output:\r\ndict_keys(['1', '3', '4'])\r\n\r\nlist(D.keys())\r\n#Output:\r\n['1', '3', '4']\r\n<\/code><\/pre>\n\n\n\n
    Python Dictionary Values Method<\/strong><\/p>\n\n\n\n
    It returns a list of values from key-value<\/strong> pairs in a dictionary, which is not in any order. However, if we call both the items()<\/strong> and values()<\/strong> method without changing the dictionary\u2019s contents between these two (items() and values()), Python guarantees that the order of the two results will be the same.<\/p>\n\n\n\n
    D = {'1':'Rohan','2':'Raju','3':'Pallu','4':'Pallavi','5':'Deeksha'}\r\nD.values()\r\n\r\n#Output:\r\ndict_values(['Rohan', 'Raju', 'Pallu', 'Pallavi', 'Deeksha'])\r\n\r\nlist(D.values())\r\n#Output:\r\n['Rohan', 'Raju', 'Pallu', 'Pallavi', 'Deeksha']\r\n<\/code><\/pre>\n\n\n\n
    Traversing Dictionary elements using for loop.<\/strong><\/p>\n\n\n\n
    In Python, you can traverse the elements of a dictionary using various methods. Here are a few common ways to iterate over dictionary elements.<\/strong><\/p>\n\n\n\n
    Example 1: Traversing Dictionary using keys<\/strong><\/p>\n\n\n\n
    D = {'1':'Rohan','2':'Raju','3':'Pallu','4':'Pallavi','5':'Deeksha'}\r\nfor i in D.keys():\r\n    print(i,\":\",D[i])\r\n\r\n#Output:\r\n1 : Rohan\r\n2 : Raju\r\n3 : Pallu\r\n4 : Pallavi\r\n5 : Deeksha\r\n<\/code><\/pre>\n\n\n\n
    Example 2 : Traversing Dictionary using values<\/strong><\/p>\n\n\n\n
    D = {'1':'Rohan','2':'Raju','3':'Pallu','4':'Pallavi','5':'Deeksha'}\r\nfor i in D.values():\r\n    print(i)\r\n\r\n#Output:\r\nRohan\r\nRaju\r\nPallu\r\nPallavi\r\nDeeksha\r\n<\/code><\/pre>\n\n\n\n
    Example 3 : Traversing Dictionary using values<\/strong><\/p>\n\n\n\n
    D = {'1':'Rohan','2':'Raju','3':'Pallu','4':'Pallavi','5':'Deeksha'}\r\nfor i in D.items():\r\n    print(i)\r\n\r\n#Output:\r\n('1', 'Rohan')\r\n('2', 'Raju')\r\n('3', 'Pallu')\r\n('4', 'Pallavi')\r\n('5', 'Deeksha')\r\n<\/code><\/pre>\n\n\n\n
    Membership Operators with Dictionary<\/strong><\/p>\n\n\n\n
    Membership operators (in and not in) can be used to check for the presence or absence of keys in a dictionary. Here’s how you can use membership operators with dictionaries in Python:<\/strong><\/strong><\/p>\n\n\n\n
    Example 1: Checking whether a key or value exists in a dictionary <\/strong><\/p>\n\n\n\n
    D = {'1':'Rohan','2':'Raju','3':'Pallu','4':'Pallavi','5':'Deeksha'}\r\n\"10\" in D.keys()\r\n#Output: False\r\n\r\nD = {'1':'Rohan','2':'Raju','3':'Pallu','4':'Pallavi','5':'Deeksha'}\r\n\"2\" in D.keys()\r\n#Output:  True\r\n\r\nD = {'1':'Rohan','2':'Raju','3':'Pallu','4':'Pallavi','5':'Deeksha'}\r\n\"Pallu\" in D.values()\r\n#Output: True\r\n<\/code><\/pre>\n\n\n\n
    Example 2:<\/strong> Check if a key does not exist in the dictionary<\/strong><\/p>\n\n\n\n
    if  “key4” not in my_dict: 
        print(“Key ‘key4’ does not exist in the dictionary.”) 
    <\/p>\n\n\n\n
    To compare dictionaries in Python, you can use the equality operator (==<\/strong>) or the cmp() function. Here’s how you can compare dictionaries using these methods:<\/p>\n\n\n\n
      \n
    1. Using the equality operator (==):<\/strong><\/li>\n<\/ol>\n\n\n\n
      dict1 = {\"key1\": \"value1\", \"key2\": \"value2\"}\r\ndict2 = {\"key1\": \"value1\", \"key2\": \"value2\"}\r\n\r\nif dict1 == dict2:\r\n    print(\"The dictionaries are equal.\")\r\nelse:\r\n    print(\"The dictionaries are not equal.\")\r\n<\/code><\/pre>\n\n\n\n
      2. Using the cmp( ) function (available in Python 2):<\/strong><\/p>\n\n\n\n
      dict1 = {\"key1\": \"value1\", \"key2\": \"value2\"}\r\ndict2 = {\"key1\": \"value1\", \"key2\": \"value2\"}\r\n\r\nif  cmp(dict1, dict2) == 0:\r\n     print(\"The dictionaries are equal.\")\r\nelse:\r\n     print(\"The dictionaries are not equal.\")\r\n<\/code><\/pre>\n\n\n\n
      Merging dictionaries: An update ( )<\/strong><\/p>\n\n\n\n
      Syntax:<\/strong>  Dic_name1.update (dic_name2)<\/strong><\/strong><\/p>\n\n\n\n
      In Python, you can merge dictionaries using the update()<\/strong> method. The update()<\/strong> method modifies the dictionary in place by adding key-value<\/strong> pairs from another dictionary. Here’s how you can use the update()<\/strong> method to merge dictionaries:<\/p>\n\n\n\n
      dict1 = {\"key1\": \"value1\", \"key2\": \"value2\"}\r\ndict2 = {\"key3\": \"value3\", \"key4\": \"value4\"}\r\ndict1.update(dict2)\r\nprint(dict1)\r\n# Output: {\"key1\": \"value1\", \"key2\": \"value2\", \"key3\": \"value3\", \"key4\": \"value4\"}\r\n<\/code><\/pre>\n\n\n\n
      In the example above, dict1.update(dict2) merges dict2 into dict1. The update() method adds all the key-value pairs from dict2 to dict1. If there are common keys between the dictionaries, the values from dict2 will overwrite<\/strong> the values in dict1 for those keys.<\/p>\n\n\n\n
      len ()<\/strong><\/p>\n\n\n\n
      This method returns the number of key-value pairs in the given dictionary.<\/p>\n\n\n\n
      D = {'1':'Rohan','2':'Raju','3':'Pallu','4':'Pallavi','5':'Deeksha'}\r\nlen(D)\r\n# Output: 5\r\n<\/code><\/pre>\n\n\n\n
      get() and setdefault() methods with dictionary.<\/strong><\/p>\n\n\n\n
      get() method: <\/strong><\/p>\n\n\n\n
      The get() method retrieves the value associated with a given key in the dictionary. It takes the key as the first argument and an optional second argument specifying a default value to return if the key is not found in the dictionary. Consider the following example:<\/p>\n\n\n\n
      my_dict = {\"key1\": \"value1\", \"key2\": \"value2\"}\r\nvalue1 = my_dict.get(\"key1\")\r\nprint(value1)  \t\t\t\t# Output: \"value1\"\r\nvalue3 = my_dict.get(\"key3\", \"default\")\r\nprint(value3)  \r\n\r\n# Output: \"default\" (since \"key3\" doesn't exist)\r\n<\/code><\/pre>\n\n\n\n
      In the example above, my_dict.get(“key1”) returns the value associated with “key1”, which is “value1”. If the key “key3” doesn’t exist in the dictionary, my_dict.get(“key3”, “default”) returns the default value “default”.<\/p>\n\n\n\n
      Another Example: <\/strong><\/p>\n\n\n\n
      picnic_items = {'apples':5,'cups':2}\r\n'I am bringing ' + str(picnic_items.get('cups',0)) + ' cups'\r\n#Output: 'I am bringing 2 cups'\r\n\r\n'I am bringing ' + str(picnic_items.get('oranges',2)) + ' oranges'\r\n#Output:'I am bringing 2 oranges'\r\n<\/code><\/pre>\n\n\n\n
      setdefault() method <\/strong>: <\/p>\n\n\n\n
      The setdefault() method returns the value associated with a given key in the dictionary. If the key doesn’t exist, it adds the key with a default value to the dictionary.<\/p>\n\n\n\n
      my_dict = {\"key1\": \"value1\", \"key2\": \"value2\"}\r\n\r\nvalue1 = my_dict.setdefault(\"key1\", \"default\")\r\nprint(value1)   \t\t\t\t# Output: \"value1\"\nvalue3 = my_dict.setdefault(\"key3\", \"default\")\r\nprint(value3)  \t\t\t\t# Output: \"default\"\r\n\r\nprint(my_dict)  \r\n# Output: {\"key1\": \"value1\", \"key2\": \"value2\", \"key3\": \"default\"}\r\n\r\n<\/code><\/pre>\n\n\n\n
      Example\u00a0<\/strong>: Get the value of the \u201ccolor\u201d item, if the \u201ccolor\u201d item does not exist, insert \u201ccolor\u201d with the value \u201csilksilver<\/strong>\u201d:<\/p>\n\n\n\n
      car = {\r\n  \"brand\": \"Hundai\",\r\n  \"model\": \"Creta\",\r\n  \"year\": 2020\r\n}\r\nx = car.setdefault(\"color\", \"silksilver\")\r\nprint(x)\r\n\r\n#Output: \r\nsilksilver\r\n\r\nx = car.setdefault(\"brand\", \"Maruthi\")\r\nprint(x)\r\n\r\n#Output: \r\nHundai\r\n\r\nx = car.setdefault(\"Price\",100000)\r\nprint(car)\r\n\r\n#Output:\r\n{'brand': 'Hundai', 'model': 'Creta', 'year': 2020, 'color': 'silksilver', 'Price': 100000}\r\n<\/code><\/pre>\n\n\n\n
      Converting a dictionary to a list of tuples<\/strong><\/p>\n\n\n\n
      Dictionary have a method called items()<\/strong> that returns a list of tuples where each tuple is a key value pair.<\/p>\n\n\n\n
      D = {'1':'Rohan','3':'Raju','4':'Pallu','2':'Pallavi','5':'Deeksha'}\r\nt = list(D.items())\r\nprint(t)\r\n\r\n#Output:\r\n[('1', 'Rohan'), ('3', 'Raju'), ('4', 'Pallu'), ('2', 'Pallavi'), ('5', 'Deeksha')]\r\n\r\nt.sort()\r\nprint(t)\r\n\r\n#Output:\r\n[('1', 'Rohan'), ('2', 'Pallavi'), ('3', 'Raju'), ('4', 'Pallu'), ('5', 'Deeksha')]\r\n<\/code><\/pre>\n\n\n\n
      Pretty Printing<\/strong><\/p>\n\n\n\n
      In Python, the pprint module provides two functions for pretty-printing data structures: pprint() and pformat()<\/strong>. These functions are useful when you want to display complex data structures, such as dictionaries or lists, in a more readable and structured format. Here’s an explanation of pprint.pprint() and pprint.pformat()<\/strong> with examples:<\/p>\n\n\n\n
        \n
      1. pprint() function:<\/strong><\/strong><\/li>\n<\/ol>\n\n\n\n
        The pprint()<\/strong> function in the pprint module prints a data structure in a formatted and more readable manner. It accepts a single argument, which can be any data structure, such as a dictionary, list, or tuple<\/strong>.<\/p>\n\n\n\n
        # printing dictionary elements using print\r\nstudent_dict = {'Name':'Tyson',\r\n                'class':'XII',\r\n                'Address': {'Flat':1308,'Block':'A','Lane':2,'City':\"Hyderbad\"}}\r\nprint(student_dict)\r\n\r\n#Output:{'Name': 'Tyson', 'class': 'XII', 'Address': {'Flat': 1308, 'Block': 'A', 'Lane': 2, 'City': 'Hyderbad'}}\r\n\r\n# printing dictionary elements using pprint.pprint()\r\nimport pprint\r\npprint.pprint(student_dict)\r\n{'Address': {'Block': 'A', 'City': 'Hyderbad', 'Flat': 1308, 'Lane': 2},\r\n 'Name': 'Tyson',\r\n 'class': 'XII'}\r\n\r\n# printing dictionary elements using pprint.pprint() with width and indent\r\npprint.pprint(student_dict,width = 2, indent =2)\r\n\r\n{ 'Address': { 'Block': 'A',\r\n               'City': 'Hyderbad',\r\n               'Flat': 1308,\r\n               'Lane': 2},\r\n  'Name': 'Tyson',\r\n  'class': 'XII'}\r\n<\/code><\/pre>\n\n\n\n
        2. pformat() function:<\/strong> <\/p>\n\n\n\n
        The pformat() function in the pprint module returns a string representation of the data structure instead of printing it directly. This can be useful if you want to store or manipulate the formatted output.<\/p>\n\n\n\n
        x = pprint.pformat(student_dict,indent =5)\r\nprint(x)\r\n\r\n#Output\r\n{    'Address': {'Block': 'A', 'City': 'Hyderbad', 'Flat': 1308, 'Lane': 2},\r\n     'Name': 'Tyson',\r\n     'class': 'XII'}\r\n<\/code><\/pre>\n\n\n\n
        Using Data Structures to Model Real-World Things<\/strong> <\/strong><\/strong><\/p>\n\n\n\n
        1. Using Data Structures to Model Chess: <\/strong><\/p>\n\n\n\n
        In the realm of algebraic chess notation, the squares on the chessboard are denoted by a combination of numerical and alphabetical coordinates, exemplified in the diagram below:<\/p>\n\n\n
        \n
        \"\"<\/figure>\n<\/div>\n\n\n
        Image Source : [1] https:\/\/automatetheboringstuff.com\/<\/a><\/p>\n\n\n\n
        Chess pieces are designated by specific letters: K<\/strong> for king, Q<\/strong> for queen, R<\/strong> for rook, B<\/strong> for bishop, and N<\/strong> for knight. Describing a move involves utilizing the letter of the piece along with the destination coordinates. A sequence of these moves portrays the events of a single turn (initiated by the white player). For example, annotation 2. Nf3 Nc6<\/strong> signifies that, on the second turn of the game, the white player advanced a knight to f3<\/strong> and the black player moved a knight to c6<\/strong>.<\/p>\n\n\n\n
        Algebraic chess notation serves as a standardized system for documenting chess movements. This system empowers players to articulate their moves using a blend of letters and numbers that symbolize the squares on the chessboard.<\/p>\n\n\n\n
        The fundamental components of algebraic chess notation encompass:<\/p>\n\n\n\n
        K<\/strong>: King<\/p>\n\n\n\n
        Q<\/strong>: Queen<\/p>\n\n\n\n
        R<\/strong>: Rook<\/p>\n\n\n\n
        B<\/strong>: Bishop<\/p>\n\n\n\n
        N:<\/strong> Knight<\/p>\n\n\n\n
        No abbreviation<\/strong> for pawns<\/p>\n\n\n\n
        Square Designation:<\/strong><\/p>\n\n\n\n
        Each square on the chessboard is designated by a combination of a letter<\/strong> (column) and a number<\/strong> (row). The letters a-h<\/strong> represent the columns from left to right<\/strong>, and the numbers 1-8<\/strong> represent the rows from bottom to top<\/strong>.<\/p>\n\n\n\n
        Move Representation:<\/strong><\/p>\n\n\n\n
        A move in algebraic notation typically consists of the piece abbreviation (if applicable), the destination square, and additional symbols to indicate the move type:<\/p>\n\n\n\n
        Pawn moves:<\/strong> Only the destination square is mentioned. If it’s a capture, the source file is indicated as well.<\/p>\n\n\n\n
        Example:<\/strong> e4, exd5 (e4 pawn moves to e5, capturing d5 pawn)<\/p>\n\n\n\n
        Other pieces:<\/strong> The piece abbreviation is followed by the destination square. If multiple pieces of the same type can move to the same square, the source file or rank is mentioned to disambiguate.<\/p>\n\n\n\n
        Example:<\/strong> Nf3 (Knight moves to f3), R1e5 (Rook on the first rank moves to e5)<\/p>\n\n\n\n
        Special Moves:<\/strong><\/strong><\/p>\n\n\n\n
        Castling:<\/strong> O-O<\/strong> for kingside castling and O-O-O<\/strong> for queenside castling.<\/p>\n\n\n\n
        En Passant:<\/strong> If a pawn captures en<\/strong> passant, the destination square is indicated and “e.p.<\/strong>” is added.<\/p>\n\n\n\n
        Example:<\/strong> exd6 e.p<\/strong>. (e5 pawn captures d6 pawn en passant)<\/p>\n\n\n\n
        Check and Checkmate:<\/strong><\/strong><\/p>\n\n\n\n
        “+”<\/strong> is added after a move to indicate a check.<\/p>\n\n\n\n
        “#”<\/strong> is added after a move to indicate a checkmate.<\/p>\n\n\n\n
        Example:<\/strong> Qh5+<\/strong> (Queen moves to h5<\/strong>, giving a check), Qh5#<\/strong> (Queen moves to h5<\/strong>, giving a checkmate)<\/p>\n\n\n\n
        Other Symbols:<\/strong><\/strong><\/p>\n\n\n\n
        \u201c=<\/strong>\u201d is used to indicate pawn promotion. It is followed by the piece abbreviation to which the pawn promotes.<\/p>\n\n\n\n
        Example:<\/strong> e8=Q<\/strong> (Pawn on e8<\/strong> promotes to a Queen)<\/p>\n\n\n\n
        By using algebraic chess notation, players can easily record and communicate their moves. It is also commonly used in chess literature, annotations, and online platforms for game analysis.<\/p>\n\n\n\n
         Using Data Structures to Model Tic-Tac-Toe<\/strong><\/p>\n\n\n\n
        The configuration of a tic-tac-toe board resembles a sizable hash symbol (#), featuring nine compartments, each capable of holding an X, an O, or remaining unoccupied. When portraying the board utilizing a dictionary, a feasible approach involves assigning a unique string-based key to each slot, as depicted in the illustration below:<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        Image Source : [1] https:\/\/automatetheboringstuff.com\/<\/a><\/p>\n\n\n\n
        Utilizing string representations, you can symbolize the contents of each slot on the board using ‘X<\/strong>‘, ‘O’<\/strong>, or ‘ ‘<\/strong> (a space character). Consequently, you will need to retain nine<\/strong> distinct strings. To achieve this, a suitable approach is to employ a dictionary comprising these string values. For instance, the string associated with the key ‘top-R<\/strong>‘ could indicate the top-right corner, the string linked to ‘low-L’<\/strong> could stand for the bottom-left corner, and similarly, the string correlated with ‘mid-M’<\/strong> could represent the middle section, and so forth. This dictionary constitutes a data structure<\/strong> that embodies the layout of a tic-tac-toe board. You can save this board-as-a-dictionary within a variable named theBoard<\/strong>.<\/p>\n\n\n\n
        theBoard <\/strong>= {‘top-L’: ‘ ‘, ‘top-M’: ‘ ‘, ‘top-R’: ‘ ‘,<\/p>\n\n\n\n
                               ‘mid-L’: ‘ ‘, ‘mid-M’: ‘ ‘, ‘mid-R’: ‘ ‘,<\/p>\n\n\n\n
                               ‘low-L’: ‘ ‘, ‘low-M’: ‘ ‘, ‘low-R’: ‘ ‘<\/p>\n\n\n\n
                             }<\/p>\n\n\n\n
        The tic-tac-toe board depicted in the illustration below is represented by the data structure stored within the variable named theBoard<\/strong>:<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        Fig<\/strong> : Empty Tic Tac Toe Board<\/p>\n\n\n\n
        Given that each key’s value within theBoard<\/strong> variable is a single-space string, this dictionary delineates an entirely vacant board. In a scenario where player X takes the initiative and selects the middle space as their move, you can use this dictionary to represent the resulting board configuration:<\/p>\n\n\n\n
        theBoard<\/strong> = {‘top-L’: ‘ ‘, ‘top-M’: ‘ ‘, ‘top-R’: ‘ ‘,<\/p>\n\n\n\n
                           ‘mid-L’: ‘ ‘, ‘mid-M’: ‘X’, ‘mid-R’: ‘ ‘,<\/p>\n\n\n\n
                             ‘low-L’: ‘ ‘, ‘low-M’: ‘ ‘, ‘low-R’: ‘ ‘}<\/p>\n\n\n\n
        The data structure contained within the theBoard<\/strong> variable now corresponds to the tic-tac-toe board illustrated in the figure below:<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        Fig<\/strong>: The First Move<\/p>\n\n\n\n
        An example of a board where player O emerges victorious by strategically placing Os across the top<\/strong> could resemble the following depiction:<\/p>\n\n\n\n
        theBoard<\/strong> = {‘top-L’: ‘O’, ‘top-M’: ‘O’, ‘top-R’: ‘O’,<\/p>\n\n\n\n
                                ‘mid-L’: ‘X’, ‘mid-M’: ‘X’, ‘mid-R’: ‘ ‘,<\/p>\n\n\n\n
                                ‘low-L’: ‘ ‘, ‘low-M’: ‘ ‘, ‘low-R’: ‘X’}<\/p>\n\n\n\n
        The data structure stored in the theBoard variable currently reflects the tic-tac-toe board illustrated in the figure below:<\/p>\n\n\n\n
        \"\"<\/figure>\n\n\n\n
        Fig: Player O wins<\/p>\n\n\n\n
        Python Program to simulate the working of Tic-Tac-Toe:<\/strong><\/p>\n\n\n\n
        theBoard = {'top-L': ' ', 'top-M': ' ', 'top-R': ' ',\r\n            'mid-L': ' ', 'mid-M': ' ', 'mid-R': ' ',\r\n            'low-L': ' ', 'low-M': ' ', 'low-R': ' '}\r\n\r\ndef printBoard(board):\r\n    print(board['top-L'] + '|' + board['top-M'] + '|' + board['top-R'])\r\n    print('-+-+-')\r\n    print(board['mid-L'] + '|' + board['mid-M'] + '|' + board['mid-R'])\r\n    print('-+-+-')\r\n    print(board['low-L'] + '|' + board['low-M'] + '|' + board['low-R'])\r\n\r\nturn = 'X'\r\n\r\nfor i in range(9):\r\n    printBoard(theBoard)\r\n    print('Turn for ' + turn + '. Move on which space?')\r\n    move = input()\r\n    theBoard[move] = turn\r\n    if turn == 'X':\r\n        turn = 'O'\r\n    else:\r\n        turn = 'X'\r\nprintBoard(theBoard)\r\n\r\n\r\n# OutPut : <\/strong>\r\n| |\r\n-+-+-\r\n| |\r\n-+-+-\r\n| |\r\nTurn for X. Move on which space?\r\nmid-M\r\n| |\r\n-+-+-\r\n|X|\r\n-+-+-\r\n| |\r\nTurn for O. Move on which space?\r\nlow-L\r\n| |\r\n-+-+-\r\n|X|\r\n-+-+-\r\nO| |\r\n--snip--\r\nO|O|X\r\n-+-+-\r\nX|X|O\r\n-+-+-\r\nO| |X\r\nTurn for X. Move on which space?\r\nlow-M\r\nO|O|X\r\n-+-+-\r\nX|X|O\r\n-+-+-\r\nO|X|X\r\n<\/code><\/pre>\n\n\n\n
        This isn\u2019t a complete tic-tac-toe game<\/strong>\u2014for instance, it doesn\u2019t ever check whether a player has won\u2014but it\u2019s enough to see how data structures can be used in programs<\/strong>.<\/p>\n\n\n\n
        Nested Dictionaries and Lists<\/strong><\/strong><\/p>\n\n\n\n
        1. Nested Dictionaries: <\/strong>A nested dictionary is a dictionary that contains other dictionaries as its values. It allows you to create a hierarchical structure to organize and store data. Each inner dictionary can have its own set of key-value pairs. Here’s an example:<\/p>\n\n\n\n
        student = {<\/p>\n\n\n\n
            ‘name’: ‘John’,<\/p>\n\n\n\n
            ‘age’: 20,<\/p>\n\n\n\n
            ‘grades’: {<\/p>\n\n\n\n
                ‘math’: 90,<\/p>\n\n\n\n
                ‘science’: 85,<\/p>\n\n\n\n
                ‘history’: 95<\/p>\n\n\n\n
            }<\/p>\n\n\n\n
        }<\/p>\n\n\n\n
        In the example above, the student dictionary has three key-value<\/strong> pairs. The ‘grades’ key has a value of another dictionary, which contains subject-grade pairs.<\/p>\n\n\n\n
        You can access the nested values by chaining the keys together. For example, to access the math grade, you can use student[‘grades’][‘math’], which will return 90.<\/p>\n\n\n\n
        2. Nested Lists:<\/strong> A nested list is a list that contains other lists as its elements. It allows you to create a multidimensional structure to store data. Each inner list can have its own set of elements. Here’s an example:<\/p>\n\n\n\n
        matrix = [\r\n    [1, 2, 3],\r\n    [4, 5, 6],\r\n    [7, 8, 9]\r\n]\r\n<\/code><\/pre>\n\n\n\n
        <\/p>\n\n\n\n
        In the example above, the matrix list contains three inner lists, forming a 3×3 matrix. You can access the elements of the nested list using indexing. For example, to access the element 5, you can use matrix[1][1], which corresponds to the second row and second column. Nested lists can be useful for representing grids, matrices, or any other data structures that require multiple dimensions.<\/p>\n\n\n\n
        Nested dictionaries and lists can be combined to create more complex data structures. For example, you can have a list of dictionaries, where each dictionary represents an entity with multiple properties, or you can have a dictionary that contains lists as its values, allowing you to group related items together.<\/p>\n\n\n\n
        Remember that when working with nested data structures, you need to carefully consider the structure and access patterns to ensure efficient and correct data manipulation.<\/p>\n\n\n\n

        <\/p>\n","protected":false},"excerpt":{"rendered":"
        Topics Covered : The Dictionary Data Type, Pretty Printing, Using Data Structures to Model Real-World Things A dictionary is a collection of items that are unordered, changeable, and indexed. Dictionary…<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":"","_links_to":"","_links_to_target":""},"class_list":["post-28032","page","type-page","status-publish","hentry"],"post_mailing_queue_ids":[],"_links":{"self":[{"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/pages\/28032","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/comments?post=28032"}],"version-history":[{"count":22,"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/pages\/28032\/revisions"}],"predecessor-version":[{"id":28078,"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/pages\/28032\/revisions\/28078"}],"wp:attachment":[{"href":"https:\/\/tocxten.com\/index.php\/wp-json\/wp\/v2\/media?parent=28032"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}