Python dictionary objects are convenient means of storing key-value pairs. Dicts provide convenience methods for data access but leave developers to their own means for operations. For example, to swap the position of two values in a python dictionary one must devise a custom approach — there is no ‘swap’ method.<\/p>\n
This is no difficult task and can be approached like any other basic swap logic implemented across many languages. Python does, however, provide does allow one to simplify the syntax of swaps — including among values in Python’s evaluation order allows simplified syntax for making swaps. Dictionary items can have values swapped using the same syntax, such that the keys are conceptually like variables. This example code provides a demonstration:<\/p>\n Swapping is a foundational concept in computer science. How one chooses to exchange the value assigned to one variable with that assigned to a second is a logical sequence approached by many programs. It’s easy — but can cause those new to programming some confusion initially. Consider the following scenario:<\/p>\n Here we have two variables; When making the second swap — assigning the value of In this approach, a copy of Here we apply the swapping approach of using a temporary value to swap the value of two entries in a Python As expected, applying the same method of using a temporary value makes this swap procedure go off without a hitch. Python is designed in such a way that the evaluation order of expressions allows us to simplify these operations.<\/p>\n Python’s evaluation order<\/a> defines the order in which expressions and assignment statements are interpreted. Before we dive into\u00a0how<\/em> swapping in Python works, let’s see the syntax in action:<\/p>\n Here the values of It is important to note that “under-the-hood” Python is using the same concept of temporary variables as we’ve been using to this point. This “syntactic sugar” merely makes the programming experience simpler. There is no avoiding the logical requirements on an absolute level. Wiht this method in mind, let us now consider how to swap two dictionary values in Python again.<\/p>\n Again, we have a dictionary object with several key-value pairs. Again, our intention is to exchange the values assigned to two keys such that they are effectively “swapped” upon completion. Consider the following example code:<\/p>\n Here we see the Pythonic way of swapping works within the confines of a Up until this point, we have been swapping the values of variables. In the case of swapping the values of two dictionary key entries, the same concept holds: we have two variables ( To swap the actual order of two items in a dictionary, we are still performing an assignment operation but, in this case, the “assignment” is the index order of the dictionary. The issue here is that dictionary objects do not have an indexed order.\u00a0<\/strong><\/p>\n To “swap” the position of two Here we see a conversion of the non-indexed This approach is interesting but not optimal. If the order of values in a Python allows the swapping of data to be approached with a minimized syntax compared to other languages. We’ve shown how to swap two values throughout this article, but the syntax extends to as many arguments as one should desire. For example, Python’s Python dictionary objects are convenient means of storing key-value pairs. Dicts provide convenience methods for data access but leave developers to their own means for operations. For example, to swap the position of two values in a python dictionary one must devise a custom approach — there is no ‘swap’ method. This is no difficult […]<\/p>\n","protected":false},"author":2,"featured_media":3003,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[10],"tags":[683,143,682],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3000"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=3000"}],"version-history":[{"count":3,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3000\/revisions"}],"predecessor-version":[{"id":3004,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3000\/revisions\/3004"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/3003"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=3000"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=3000"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=3000"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}dict<\/code> objects. This quick tutorial will look at several approaches and use-cases for swapping values in a Python dict<\/code>.<\/p>\nTL;DR<\/h2>\n
# define key value pairs\r\nd = {\"a\": 1, \"b\": 2, \"c\": 3}\r\n\r\n# swap values using Pythonic syntax\r\nd[\"a\"], d[\"b\"] = d[\"b\"], d[\"a\"]\r\n\r\n# result\r\n{'a': 2, 'b': 1, 'c': 3}<\/pre>\nQuick Intro: Swapping Basics<\/h2>\n
# The first variable\r\nvariable_one = 1\r\n\r\n# The second variable\r\nvariable_two = 2<\/pre>\n
variable_one<\/code> and variable_two<\/code>. Each has a unique integer value assigned. Our intention is to change them such that variable_1<\/code> has a resulting value of 2<\/code> and variable_2<\/code> has a resulting value of 1<\/code>. We can easily assign the value of variable_2<\/code> to variable_1<\/code> but that’s where the trouble begins. Consider the following:<\/p>\n# swap first value\r\nvariable_1 = variable_2\r\n\r\n# swap second value\r\nvariable_2 = variable_1 # <--------- keeps the same value!<\/pre>\n
variable_1<\/code> to variable_2<\/code>, there is no change because the value of variable_2<\/code> had just been assigned to variable_1<\/code>. The second part of this code is equivalent of saying variable_2 = variable_2<\/code>. Clearly, this isn’t “swapping” anything! The solution is to use a temporary value as such:<\/p>\n# create a temporary value\r\ntmp = variable_1\r\n\r\n# make first swap in same fashion\r\nvariable_1 = variable_2\r\n\r\n# make second swap, using tmp value\r\nvariable_2 = tmp # <------- swap works here<\/pre>\n
variable_1<\/code> is made before it is reassigned to another value. This provides the means of accessing that initial value after-the-fact such that our next assignment works as intended. This is a fundamental<\/em> logical concept in computer science and programming.\u00a0<\/strong>Let’s consider how to apply this to the swapping of two dict<\/code> values in Python.<\/p>\nSwap Two Dict Values<\/h2>\n
dict<\/code> object. Consider the following code:<\/p>\n# define key value pairs\r\ndict_items = {\"a\": 1, \"b\": 2, \"c\": 3}\r\n\r\n# swap values of a and b\r\ntmp = dict_items[\"a\"]\r\n\r\n# Make first swap\r\ndict_items[\"a\"] = dict_items[\"b\"]\r\n\r\n# Make second, using tmp value\r\ndict_items[\"b\"] = tmp\r\n\r\n# View output\r\nprint(dict_items)\r\n\r\n{'a': 2, 'b': 1, 'c': 3}<\/pre>\nPython-Specific Swapping<\/h2>\n
# Define two variables\r\nvariable_1 = 1\r\nvariable_2 = 2\r\n\r\n# swap values Pythonically\r\nvariable_1, variable_2 = variable_2, variable_1\r\n\r\n# View result\r\nprint(\"variable_1:\", variable_1)\r\nprint(\"variable_2:\", variable_2)\r\n\r\nvariable_1: 2\r\nvariable_2: 1<\/pre>\n
variable_1<\/code> and variable_2<\/code> are swapped without using a temporary variable! But, how can that be? Under the hood, Python’s evaluation order does something similar to the following:<\/p>\n\n
variable_1<\/code> and variable_2<\/code>.<\/li>\nvariable_1<\/code>) is assigned to the first value on the RHS (variable_2<\/code>).<\/li>\n<\/ol>\nSwap Two Dict Values Pythonically<\/h2>\n
# define key value pairs\r\nd = {\"a\": 1, \"b\": 2, \"c\": 3}\r\n\r\n# swap Pythonically\r\nd[\"a\"], d[\"b\"] = d[\"b\"], d[\"a\"]\r\n\r\n# view result\r\nprint(\"Result:\", d)\r\nResult: {'a': 2, 'b': 1, 'c': 3}\r\n\r\n<\/pre>\ndict<\/code> object just as it does with non-dict<\/code> variable objects. This is effective for swapping the values of two dict<\/code> items but what if we wanted to swap the position of two items in a Python dictionary? For that, we need to incorporate some additional logic!<\/p>\nSwap Position of Two Items in a Python Dict<\/h2>\n
dict<\/code> items in this case) to which we are performing an assignment operation<\/strong>.<\/p>\ndict<\/code> items we must first convert the dict<\/code> object to an orderable object, like a list<\/code> or tuple<\/code>. Given dict<\/code> objects have key-value\u00a0pairs<\/em>, a tuple<\/code> object fits perfectly. Consider the following approach:<\/p>\n# define key value pairs\r\nd = {\"a\": 1, \"b\": 2, \"c\": 3}\r\n\r\n# convert to a tuple\r\nt = list(d.items())\r\nprint(\"Tuples:\", t)\r\n\r\n>>> Tuples: [('a', 1), ('b', 2), ('c', 3)]\r\n\r\n\r\n# swap order via index values\r\nt[0], t[1] = t[1], t[0]\r\nprint(\"Swapped:\", t)\r\n\r\nSwapped: [('b', 2), ('a', 1), ('c', 3)]\r\n\r\n\r\n# Convert back to dictionary\r\nd = dict(t)\r\nprint(\"Result:\", d)\r\n\r\nResult: {'b': 2, 'a': 1, 'c': 3}\r\n<\/pre>\ndict<\/code> object d<\/code> into an indexed list<\/code> object of tuple<\/code> pairs t<\/code> such that the “swap” is between index values. This swap happens with the same assignment order expression syntax, just outside of the dict<\/code> object. Then, the correctly swapped values are converted back into a dict<\/code> object.<\/p>\nDisclaimer<\/h3>\n
dict<\/code> object needs to be altered there is a strong chance that another data structure like a list or tuple is a better choice to hold references to data. There are plenty of data structures<\/a> out there, each better suited to certain situations.<\/p>\nFinal Thoughts<\/h2>\n
a, b, c, d, e = d, c, e, b, a<\/code> is completely value syntax.<\/p>\ndict<\/code> objects are incredibly powerful tools when applied appropriately but, as with other hash table-esque<\/em> data structures, not ideal for storing data such that order is important (or predictable!) Nevertheless, performing actions like swaps or even sorting a Python dictionary<\/a> is possible and, in the right circumstance, possibly appropriate.<\/p>\n","protected":false},"excerpt":{"rendered":"