- Introducing Python Sets 5:56
- Practice Files
- The First Property: No Order 3:58
- The Second Property: No Duplicates 7:24
- Immutable Data Types 7:45
- The Set Constructor Function 10:38
- Sets Simplify Data Processing 5:03
- Set Mutability: Adding Elements 4:44
- Set Mutability: Deleting Elements 11:33
- Set Membership & Relationship 11:03
- Set Operations: Union & Intersection 6:55
- Set Operations: Symmetric Difference & Difference 5:55
- Exercise 7:03
- Conclusion
Preview
Video Player
00:00
00:00
Set Mutability: Deleting Elements
11:33There are four methods to remove an element from a set: clear, remove, discard, pop.
There are four methods that
remove elements from a set.
0:00
Clear, remove, discard, and pop.
0:05
Let's go through what each one
of these does with examples.
0:09
But before we move on, let's remember
that the set data type is mutable.
0:14
That means that the data
inside of it can change.
0:20
I only have one set right
now, my vowels, and
0:23
I would not like to change
anything in that set.
0:25
So, I'll use the copy method so that I can
mutate a copy instead of the original.
0:28
For each example,
0:36
I'll mutate a copy
instead of the original.
0:41
And just to show you what this does,
it does exactly what it says it is.
0:50
It copies the set.
0:56
So example one should be a set of
five vowels, A, E, I, O and U, and
0:58
it might not be in the same
order as line six vowels.
1:03
There we go.
1:08
All right, so the first method that
I wanna show you is called clear.
1:10
example_1.clear(), close parentheses
to call the method and
1:21
we'll print example_1
to see what happened.
1:26
I've now got an empty set.
1:33
So clear removes all
elements from the set.
1:35
It's a good thing that we made
a copy before doing that.
1:49
The second method is called remove.
1:54
And it takes one argument.
2:04
Let's remove the letter E.
2:07
I'll run my script again.
2:20
And we'll see that E is
no longer in this set.
2:24
If I try to remove something
that doesn't exist in the set,
2:30
that is,
if I try to invoke the remove method
2:36
And the element that I pass in as an
argument here is not a member of the set,
2:40
I'll get a key error.
2:48
Trace back line 14, example_2.remove('E'),
there's a key error.
2:55
E is no longer in the set, and
that will work if I even say F.
3:01
F is not a vowel,
we never had it in A, E, I, O, or U.
3:08
So if I run the script again,
I'll see the same message, but
3:13
it will give me a key error for
the string capital F.
3:16
The third method, discard,
3:24
works similarly as remove, but
3:27
it will not throw an error when
an element is not a member of the set.
3:32
So I've discarded the letter E.
3:54
It's no longer in my second set down here.
3:57
But watch what happens when
I duplicate this line,
4:00
and I run my script again, so
unlike remove I get no error.
4:06
And right here, I do have a key error.
4:17
And I can discard as many times as I want.
4:25
It's very similar to the add method,
4:28
when we were learning how
to add elements into a set.
4:31
After the first time,
it no longer has an effect on the set, and
4:35
it will be silent on subsequent runs.
4:39
Since remove and
discard are pretty similar,
4:43
how do we decide which one to use?
4:46
Well, it just depends on whether or
not you need the key error to occur.
4:49
For example,
if you are using a try-except block,
4:53
remove is ideal because you can write
an exception to catch the key error.
4:57
Otherwise, if you don't care
about handling exceptions and
5:02
you don't want an error to crash
your program, just use discard.
5:05
The last method, pop, will remove and
5:11
return a random member of a set.
5:16
So here I actually want to,
I said that it will remove and return.
5:40
But what I actually want to
do is vowel equals vowel.pop().
5:46
Print example_4, and
then print my one vowel.
5:52
There we go.
5:59
So we can see here,
my original vowels has five.
6:04
My vowel, this should be four but
I see what happened here.
6:12
On line 24, this should say example_4,
not vowels.
6:18
So let me run this script again.
6:23
There we go.
6:27
So my original vowel set
has five vowels in it.
6:29
My example_4 set has four vowels, and
6:33
it removed and
returned the letter U print vowel.
6:37
And I can run this again, and
6:43
it will give me a different
element because it's random.
6:47
The first few times it didn't look
like it was random but it was.
6:56
You can see O, U, E,
there's another U, there's another O.
7:00
Now pop is a very interesting
method out of all the ones that
7:05
are built into the set data type.
7:09
It's the only one that returns and
retrieves an element from the collection.
7:13
There's no other way to access an element
in a set other than using pop.
7:19
And when you do,
it's removed from the set.
7:24
Notice here on line 24 how I've assigned
the return value of pop to a variable.
7:28
But in my previous three examples,
example three,
7:35
example two and example one,
I don't do that.
7:40
I do not assign the return value
of those methods to a variable.
7:44
That is because those methods operate
by what's known as side effects.
7:52
You call the method and
then it has an effect on something else.
7:58
So in this example, three,
we called discard and
8:02
it affected the original, example three.
8:07
If I were to assign
a variable to let's say,
8:11
here, example_return
equals example_3.discard.
8:17
And I try to print that out.
8:26
What will happen is
8:29
that I will get none.
8:34
And the same goes for the other methods
too, discard, remove and clear.
8:40
They all operate by side effects and
they return none.
8:45
But we don't want
the return value of none,
8:50
we want the return value of the set
itself that we manipulated.
8:53
So I'm gonna delete that.
8:58
It's just a little fun fact here.
8:59
Pop is the one that you'll want to assign
a variable to if you're trying to retrieve
9:02
an element out of that set.
9:07
And pop takes no arguments.
9:10
So you can't control which element
that you get out of the set.
9:13
You remember if I scroll up
here in my terminal, I see O,
9:16
U, U, and I didn't really have
a choice as to what came out of that.
9:22
Pop will return a random
9:28
element every time, and
9:33
watch what happens if I run pop six times.
9:38
So that's one for every vowel and then
a six-time for something that's not there.
9:47
So if I run pop on an empty set, whoops.
9:52
Print example.
9:58
Let's see, one, two, three,
four, print example_4.
10:02
What happens is I get an error.
10:10
It's a key error, pop from an empty set.
10:14
So pop will throw an error message
if it's called on an empty set.
10:18
It's the only method that allows us
to retrieve an element of the set and
10:22
it's always a random element.
10:26
So this is a lot different than
using the pop method with lists and
10:28
strings where we can access elements
by calling an index or a slice.
10:32
Remember that sets are not sequences, so
10:38
you can't access elements from an index or
slice.
10:41
Instead of referencing
elements by position,
10:45
elements in a set are referred
to by their membership.
10:48
And we tested for
membership earlier in this
10:52
video with our syntax A in
vowels which returns true.
10:58
(Comment out these lines.)
11:17
True, A is in vowels.
11:23
So what exactly does this mean?
11:25
Well, we'll learn more about this concept
of set membership in the next video.
11:27