{"id":524,"date":"2020-12-30T11:47:04","date_gmt":"2020-12-30T16:47:04","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=524"},"modified":"2022-06-16T15:23:57","modified_gmt":"2022-06-16T19:23:57","slug":"python-set-update-method","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/python-set-update-method-044711\/","title":{"rendered":"Using Python’s set.update() Method for Fun & Profit"},"content":{"rendered":"

Python’s set is a powerful collections data type that offers several performance benefits over list objects in certain cases. The set.update<\/code> method provides a convenient way to add multiple items to a set in Python. This provides a notable benefit over the set.add()<\/code> method used to add single items.<\/p>\n

Python is one of the world’s most popular programming languages<\/a> for good reason\u2014it provides powerful built-in data types to handle common problems. The set<\/code> datatype can be used for performant collections where uniqueness is required. Python’s sets<\/code> are more performant than lists when it comes to lookups but slightly less performant when iterating over elements.<\/p>\n

Quick Introduction to Python’s Set<\/span> Datatype<\/h2>\n

Python sets provide several methods by which elements can be added, removed, or retrieved. The most straightforward (ish) method is the set.add()<\/code> method. The official Python documentation describes sets in the following way (R<\/a>):<\/p>\n

A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.<\/em><\/p>\n

Some notable takeaways are no duplicate elements<\/strong>, membership testing<\/strong>, and fancy mathematical operations<\/strong>. Those are considered the defining characteristics of Python’s set<\/code> datatype.<\/p>\n

Python’s set.update<\/span> Method<\/h2>\n

To\u00a0really<\/em> get an idea of Python’s set.update<\/code> method one needs to compare with the set.add<\/code> method. This comparison will stratify the use-cases and underlying functionality by which set.update<\/code> should be chosen. So\u2014we’re focused on set.update<\/code> but I’ll be including a few comparative examples along the way.<\/p>\n

Adding Single Elements<\/h3>\n

Below is a quick example of creating a set and adding elements via the set.add<\/code> method. Note the second example’s error indicating that only single items<\/em> can be added this way. That’s the hallmark indication that one should consider the update method. Otherwise, one must iterate over all elements intended to be added in a loop (last example). See below:<\/p>\n

# Create a set literal\r\nsample_set = {1, 2, 3}\r\n>>> {1, 2, 3}\r\n\r\n# Add a single element\r\nsample_set.add(4)\r\n>>> {1, 2, 3, 4}\r\n\r\n# Add multiple elements\r\nsample_set.add(5, 6, 7)\r\n>>> TypeError: add() takes exactly one argument (3 given)\r\n\r\n# A possible work-around\r\nfor item in [5, 6, 7]:\r\n    sample_set.add(5, 6, 7)\r\n>>> {1, 2, 3, 4, 5, 6, 7}<\/pre>\n
Note<\/strong>: I’ve created a set using literal notation rather than the set()<\/code> notation. This syntax cannot be used to create empty sets as it will create an empty dictionary object.<\/div>\n
Adding Multiple Elements<\/h3>\n
The addition of multiple elements to a set<\/code> is where the set.update()<\/code> method comes in. Its use is straightforward, but there’s some notable context in which one must be careful.<\/p>\n
# Create a set literal\r\nsample_set = {1, 2, 3}\r\n>>> {1, 2, 3}\r\n\r\n# Add multiple elements\r\nsample_set.update(4, 5, 6)\r\n>>> TypeError: add() takes exactly one argument (3 given)\r\n\r\n# Add multiple elements, from and iterable\r\nsample_set.update([4, 5, 6])\r\n>>> {1, 2, 3, 4, 5, 6}<\/pre>\n
Dictionary Objects<\/h4>\n
Note here that the set.update method requires an iterable<\/em> of multiple items Qualifying structures include Lists<\/code>, Tuples<\/code>, and even Dictonary<\/code> objects. Also, note that the set.update() method will use only the keys from a Dictionary<\/code> object. For example:<\/p>\n
# Create a new set\r\nset_one = {1, 2, 3}\r\n\r\n# Update with dictionary literal\r\nset_one.update({4: \"a\", 5: \"b\", 6: \"c\"})\r\n\r\n# Note only dictionary keys being added\r\n>>> {1, 2, 3, 4, 5, 6}<\/pre>\n
Python will also allow the creation of a dictionary object using multiple keys, though duplicate values will be ignored. This may cause some confusion and is worth keeping in mind\u00a0particularly<\/em> when working with dictionary objects\u00a0and<\/em> set objects. For example:<\/p>\n
# Create a new dictionary object\r\ndict_obj = {4: \"a\", 5: \"b\", 6: \"c\", 6: \"d\"}\r\n\r\n# Data discarded for duplicate keys\r\n>>> {4: 'a', 5: 'b', 6: 'd'}<\/pre>\n
Tuple Objects<\/h4>\n
Tuples are another case where one needs to be careful. Whereas tuples are added\u00a0in their entirety<\/em> using the add() method\u2014the update adds individual elements. If the membership of a tuple is important the add() method is more appropriate. For example:<\/p>\n
# Create a new set object\r\nset_one = {1, 2, 3}\r\n\r\n>>> {1, 2, 3}\r\n\r\n# Update with tuple value\r\nset_one.update((4, 5, 6, 6))\r\n\r\n>>> {1, 2, 3, 4, 5, 6}\r\n\r\n# Update with iterable containing tuple\r\nset_one.update(((7, 8, 9, 9), ))\r\n\r\n>>> {1, 2, 3, 4, 5, 6, (7, 8, 9, 9)}<\/pre>\n
In the last example, note that a tuple added as a member of an iterable is added in its entirety. This illustrates that the set.update()<\/code> method is not recursive<\/em>.<\/p>\n
String Objects<\/h4>\n
Adding strings to sets come with a few edge cases to be aware of also. Most notably, the possible interpretation of strings as character<\/code> iterables<\/em>. Remember that the update()<\/code> method takes an iterable as its argument\u2014the add method takes a single item. When passing a string of multiple characters to the update method, it’ll be interpreted as an iterable and treated as such. Consider the following example:<\/p>\n
# Create a new set object\r\nset_one = {1, 2, 3}\r\n\r\n# Using the add method, add a string\r\nset_one.add(\"tabs\")\r\n\r\n>>> {'tabs', 1, 2, 3}\r\n\r\n# Using the update method, add a string\r\nset_one.update(\"spaces\")\r\n\r\n>>> {1, 2, 3, 'a', 'tabs', 'c', 'e', 's', 'p'}\r\n\r\n# Using the update method and extra iterable\r\nset_one.update([\"EOL\"])\r\n\r\n>>> {1, 2, 3, 's', 'p', 'c', 'e', 'tabs', 'EOL', 'a'}<\/pre>\n
These examples illustrate two defining characteristics of the set.update() method in my opinion:<\/p>\n
    \n
  1. The method takes an iterable<\/strong> as an argument;<\/li>\n
  2. The method does not recurse<\/strong> into arguments.<\/li>\n<\/ol>\n
    Final Thoughts<\/h2>\n
    It’s clear that Python’s set.update()<\/code> method has some preferred use cases. Generally, it’s preferred when one needs to add multiple items to a set object. Sets provide much more performant membership testing\u2014especially for large datasets\u2014though slightly less performant iterability.<\/p>\n
    Keeping in mind the use and<\/em> edge cases listed here can help better assess when performance gains of sets outweigh losses compared to other collection data types such as lists. Also, almost certainly, keeping in mind the use cases, dynamics, and edge-case concerns of the set.update()<\/code> method will prove beneficial when wrangling data in any project.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Python’s set is a powerful collections data type that offers several performance benefits over list objects in certain cases. The set.update method provides a convenient way to add multiple items to a set in Python. This provides a notable benefit over the set.add() method used to add single items. Python is one of the world’s […]<\/p>\n","protected":false},"author":2,"featured_media":525,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[655,10],"tags":[222,69,143,221],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/524"}],"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=524"}],"version-history":[{"count":3,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/524\/revisions"}],"predecessor-version":[{"id":528,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/524\/revisions\/528"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/525"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=524"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=524"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=524"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}