# Different Update Methods

**Sets in Python**James Uejio 05:56

**00:00**
Let’s look at some more set modifying operations. All of the ones in this video will have a method and a corresponding augmented assignment. They will also correspond to some of the set operations—union, intersection, difference, and symmetric difference.

**00:19**
Starting with update, this modifies the set by adding any elements that do not already exist. It’s very similar to union, where that will create a set with all elements in all sets. So instead of creating a new set, we actually change the set to include all elements.

**00:37**
Here’s the method, `.update()`

. It takes in multiple arguments, and they need to be iterables.

**00:43**
Here is the augmented assignment. The operands need to be sets. This is different than the operator that you saw in previous videos because the operator creates a new set while augmented assignment modifies the existing set `x1`

. Let’s look at some examples.

**01:02**
`x1`

is a set with `{'foo', 'bar', 'baz'}`

, `x2`

is a set with `{'foo', 'baz', 'qux'}`

. We use the augmented assignment to change `x1`

to include all the elements of `x2`

. So then `x1`

will be `{'qux', 'foo', 'bar', 'baz'}`

.

**01:20**
Notice how `'foo'`

doesn’t appear twice, as well as `'baz'`

doesn’t appear twice. And it is unordered, so they just appear in some random order.

**01:31**
Here we can also update `x1`

using the method and pass in the list of `['corge', 'garply']`

, and that will update `x1`

to now include those two strings as well as all the other elements it originally had.

**01:47**
Intersection update corresponds with intersection and modifies a set by retaining only elements found in both sets. `.intersection_update()`

takes in multiple arguments, and here is the augmented assignment, ampersand equal (`&=`

).

**02:03**
So here’s our example. We have `{'foo', 'bar', 'baz'}`

, we have `{'foo', 'baz', 'qux'}`

. We use `x1 &= x2`

, and that will change `x1`

to include only the elements found in both sets, which are `'foo'`

and `'baz'`

.

**02:19**
We can call the method and pass in a list of `['baz', 'qux']`

, and we will only retain those elements that are both in `x1`

and in this list, which is just `{'baz'}`

.

**02:33**
Moving on to difference update, which corresponds to the difference operation. It modifies a set by keeping only elements that exist in the first set, but not any of the rest.

**02:43**
Here we have `x1.difference_update(x2[, x3...])`

, and this will modify `x1`

to keep only elements that exist in `x1`

, not `x2`

or `x3`

, et cetera. The arguments need to be iterables.

**02:56**
Here is the augmented assignment, `-= x2`

, and then we actually have union`| x3 | x4`

. Operands need to be sets. Note, there is the union operator between multiple operands.

**03:12**
This will mutate `x1`

by checking the union of all sets, `x2`

, `x3`

, and remove any elements from `x1`

that exist in the union.

**03:20**
`x1 -= x2 - x3`

et cetera won’t do this, and we’ll see that in the example.

**03:28**
Here we have `a`

is the set `{1, 2, 3}`

, `b`

is the set `{2}`

, `c`

is the set `{3}`

. And then we call `a.difference_update(b, c)`

, we remove all the elements found in `b`

or `c`

from `a`

, and that will give us the set `{1}`

. Here we reset `a`

. Remember, we’re using a mutation now, and so we actually have to reset `a`

if we want to use the set `{1, 2, 3}`

.

**03:53**
Then we do `a - b | c`

. It will first evaluate the union `b | c`

, which will be the set `{2, 3}`

, and then remove those elements from `a`

. We reset `a`

, and let’s try to use the `-=b - c`

.

**04:11**
That will evaluate `b - c`

, which will find the difference of `b`

and `c`

, which will be the set `{2}`

because, remember, difference finds all the elements in the first set that do not exist in the second set.

**04:23**
So that’s essentially doing `a -= {2}`

, which will remove `2`

from our original set. So this was not the same as calling `.difference_update(b, c)`

.

**04:37**
Symmetric difference update will modify a set by keeping only the elements that exist in a single set, but not in multiple. `x1.symmetric_difference_update(x2)`

will modify `x1`

so that `x1`

only includes elements that exist in either `x1`

or `x2`

.

**04:54**
The argument needs to be editable, and for some reason, it only takes in one argument. Here’s the augmented assignment, `^=`

. Operands need to be sets, and this will mutate `x1`

to include all elements found in either any of the sets, but not in multiple sets.

**05:12**
Here’s an example. We have `a`

is `{1, 2, 3}`

, `b`

is a set `{3, 4, 5}`

, `c`

is a set `{1, 5, 6}`

.

**05:21**
We call `a.symmetric_difference_update(b)`

. That will update `a`

to include only elements found in either set, but not both. That will be `{1, 2, 4, 5}`

.

**05:34**
Here we reset `a`

, and then we use the augmented assignment `^=`

to update `a`

to include only elements found in one set, but not multiple.

**05:45**
So here, those elements would be `{2, 4, 6}`

, because `2`

, `4`

, `6`

are only found in one set, but not multiple.

**James Uejio** RP Team on April 29, 2020

@Sciencificity Thank you for the comment and this is definitely tricky. So what actually happened is Python evaluated the right hand side of the expression first (b ^ c) and then modified a.

You can think of it like this:

```
a = {1,2,3}
b = {3,4,5}
c = {1,3,5,6}
# step 1
print(b ^ c)
{1, 4, 6}
# step 2
print(a ^ {1, 4, 6})
{2, 3, 4, 6}
# step 3
Modify a to be equal to {2, 3, 4, 6}
```

**Victoria** on March 27, 2023

```
The explanation in the video is not correct. A counter-example, by adding another set.
a = {1, 2, 3}
b = {3, 4, 5}
c = {1, 5, 6}
d = {1} # additional set
a ^= b ^ c ^ d
# {1, 2, 4, 6}
```

The `^`

operations are chained and evaluated on the right first, before the final operation and assignment.

Become a Member to join the conversation.

Sciencificityon April 27, 2020Hi James,

Here again I believe that the

`symmetric_difference_update()`

only works on 2 sets for a reason (hence the ^= operator too, should be used only with 2 sets)If we take the 3 set example used in the videos, and introduce a 3 in the last set we notice the weird behaviour for more than 2 sets.

Well, that’s my thinking anyway. Please let me know if I am thinking about it incorrectly?

Thanks for a really great course! It is just this concept which is confusing for me.