pop() removes an arbitrary element from the set and returns that element. 

If the set is empty, it will raise a TypeError exception.

Usage Example:

University of Illinois at Urbana-Champaign

Different operations can be performed on a set. Important operations include:
- Accessing a set item:

You can access all items in the set by looping over it, as shown.
```python
for x in set:
    print(x)
```
You can check if a specific value is present in the set as well.
```python
print(x in set)
```
- Adding a set item:

You can add a set item by using the add() method as shown.
```python
set.add(x)
```
You may also want to add all items from a different iterable (does not need to be a set) to your set. In this case, you may use the update method.
```python
setA = {"apple", "orange", "banana"}
setB = {"kiwi", "mango", "pineapple"}
setB.update(setA)
```
- Removing a set item:

You can remove a set item by using the remove() method as shown.
```python
set.remove(x)
```
- Joining two sets:

You can create a set that contains all the items from two sets by using the union operation. This is similar to adding all items from a different iterable, but different because rather than adding all elements from setA to setB, you are creating a new set (setC) that contains all elements of setA and setB.
```python
setA = {"apple", "orange", "banana"}
setB = {"kiwi", "mango", "pineapple"}
setC = setB.union(setA)
```
Other methods that may be used include:
- clear()
- copy()
- difference()
- discard()
- intersection()
- isdisjoint()
- issubset()
- issuperset()
- pop()
- symmetric_difference()

Set Operations

Python Documentation

The clear() method removes all items from a set structure. Usage:
```python
students = {"John", "Joe", "Jerry"}

students.clear()
print(student)
```
The clear() method removes all items in the student dictionary. The final print statement outputs `{}`.

clear()

The copy() method returns a copy of the set. Usage:
```python
students = {"John", "Joe", "Jerry"}

clone = students.copy()
print(clone)
```
The students set is copied to clone. The final print statement outputs `{'John', 'Joe', 'Jerry'}`.

copy()

The difference() method returns a set containing the difference between two or more sets. The difference_update() method removes the items that exist in both sets. Usage:
```python
colors = {"red", "yellow", "orange"}
fruits = {"apple", "banana", "orange"}

diff1 = colors.difference(fruits)
print(diff)
colors.difference_update(fruits)
print(colors)
```
The first print statement outputs `{'red', 'yellow'}` as both sets contain the element `'orange'`.

The second print statement outputs `{'red', 'yellow'}` as well, but `difference_update()` changes the contents of the `colors` set by removing `'orange'`.



difference(set) and difference_update(set)

The discard() method removes the specified element from the set.

Example usage:



discard(x)

intersection(x) returns a new set with elements which are shared by all sets.

Usage example:

intersection(x)

pop()

x.isdisjoint(y) method returns True if no items in set x are present in set y.

```python
colors = {"red", "yellow", "orange"}
fruits = {"apple", "banana", "orange"}
cars = {"Toyota", "Honda", "Audi"}

x = colors.isdisjoint(fruits); // x = False
y = colors.isdisjoint(cars); // y = True
```
x is set to False as the `colors` and `fruits` sets share a common element (`orange`). y is set to True as the `colors` and `cars` sets have no shared elements.

isdisjoint(set)

x.issubset(y) returns True if x is a subset of y, or, in other words, all items in set x are present in set y.

```python
colors = {"red", "orange"}
rainbow = {"red", "orange", "yellow", "green", "blue", "indigo", "violet"}
cars = {"Toyota", "Honda", "Audi"}

x = colors.issubset(rainbow); // x = True
y = colors.issubsete(cars); // y = False
```
x is set to True as the rainbow set contains all the elements of the colors set. y is set to False as the cars set does not contain all elements of the colors set.

issubset(set)

x.issuperset(y) returns True if x is a superset of y, or, in other words, all items in set y are present in set x.
```python
rainbow = {"red", "orange", "yellow", "green", "blue", "indigo", "violet"}
colors = {"red", "orange"}
cars = {"Toyota", "Honda", "Audi"}

x = rainbow.issuperset(colors); // x = True
y = rainbow.issuperset(cars); // y = False
```
x is set to True as all the elements in colors are contained in rainbow. y is set to False as rainbow does not contain all the elements of cars.

issuperset(set)

The symmetric_difference() method returns a set containing all items from both sets excluding those that are present in both. The symmetric_difference_update() method removes the items that exist in both sets and inserts the items that are not present in both sets. Usage:

```python
colors = {"red", "yellow", "orange"}
fruits = {"apple", "banana", "orange"}

diff1 = colors.difference(fruits)
print(diff)
colors.difference_update(fruits)
print(colors)
```
The first print statement outputs {'red', 'yellow', 'apple', 'banana'} as both sets contain the element 'orange'.

The second print statement outputs {'red', 'yellow', 'apple', 'banana'} as well, but symmetric_difference_update() changes the contents of the colors set by removing 'orange' and adding 'apple' and 'banana'.

Learn Before

Related