Python Collections – ██FR█████ █INTELL███████████

This content originally appeared on DEV Community and was authored by Harsh Mishra

Lists in Python

Lists are one of the most versatile and widely used data types in Python. They allow you to store collections of items in a single variable. Here’s everything you need to know about lists in Python.

Creating Lists

Lists are created by placing a comma-separated sequence of items within square brackets [].

# Creating a list of integers
numbers = [1, 2, 3, 4, 5]

# Creating a list of strings
fruits = ["apple", "banana", "cherry"]

# Creating a mixed data type list
mixed = [1, "hello", 3.14, True]

# Creating a nested list
nested = [[1, 2], [3, 4], [5, 6]]

Accessing Elements

You can access elements of a list by using indexing. Indexing starts at 0.

numbers = [1, 2, 3, 4, 5]
print(numbers[0])  # Output: 1
print(numbers[4])  # Output: 5

Negative indexing allows you to access elements from the end of the list.

print(numbers[-1])  # Output: 5
print(numbers[-2])  # Output: 4

Slicing Lists

You can retrieve a part of a list by using slicing. The syntax for slicing is list[start:stop:step].

# Creating a list of numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slicing from index 2 to 5
print(numbers[2:6])  # Output: [3, 4, 5, 6]

# Slicing with step
print(numbers[::2])  # Output: [1, 3, 5, 7, 9]

# Slicing with negative step (reversing the list)
print(numbers[::-1])  # Output: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Modifying Lists

Lists are mutable, meaning you can change their content.

numbers = [1, 2, 3, 4, 5]

# Changing an element
numbers[0] = 10
print(numbers)  # Output: [10, 2, 3, 4, 5]

# Changing a range of elements
numbers[1:3] = [20, 30]
print(numbers)  # Output: [10, 20, 30, 4, 5]

List Concatenation

You can concatenate two or more lists using the + operator.

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(combined)  # Output: [1, 2, 3, 4, 5, 6]

List Comprehensions

List comprehensions provide a concise way to create lists. It consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses.

# Creating a list of squares
squares = [x**2 for x in range(10)]
print(squares)  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Filtering with list comprehensions
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # Output: [0, 4, 16, 36, 64]

Iterating Over Lists

You can iterate over the elements of a list using a for loop.

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# Output:
# apple
# banana
# cherry

Checking Membership

You can check if an item exists in a list using the in keyword.

fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)  # Output: True
print("grape" in fruits)  # Output: False

List Length

You can get the number of items in a list using the len() function.

fruits = ["apple", "banana", "cherry"]
print(len(fruits))  # Output: 3

Copying Lists

Copying a list can be done in several ways. It’s important to note that simply using the assignment operator (=) does not create a copy but rather a reference to the same list.

# Using slicing
original = [1, 2, 3]
copy = original[:]
print(copy)  # Output: [1, 2, 3]

# Using the list() function
copy = list(original)
print(copy)  # Output: [1, 2, 3]

# Using the copy() method (Python 3.3+)
copy = original.copy()
print(copy)  # Output: [1, 2, 3]

Nesting Lists

Lists can contain other lists, allowing you to create complex data structures like matrices.

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Accessing nested list elements
print(matrix[0][1])  # Output: 2

Unpacking Lists

You can unpack lists into variables directly.

numbers = [1, 2, 3]
a, b, c = numbers
print(a, b, c)  # Output: 1 2 3

# Extended unpacking (Python 3.0+)
numbers = [1, 2, 3, 4, 5]
a, *b, c = numbers
print(a, b, c)  # Output: 1 [2, 3, 4] 5

Lists Methods in Python

Adding Elements

append

Appends an item to the end of the list.
Syntax: list.append(item)

numbers = [1, 2, 3]
numbers.append(4)
print(numbers)  # Output: [1, 2, 3, 4]

extend

Extends the list by appending all the items from the iterable.
Syntax: list.extend(iterable)

numbers = [1, 2, 3]
numbers.extend([4, 5])
print(numbers)  # Output: [1, 2, 3, 4, 5]

insert

Inserts an item at a given position.
Syntax: list.insert(index, item)

numbers = [1, 2, 3]
numbers.insert(1, 1.5)
print(numbers)  # Output: [1, 1.5, 2, 3]

Removing Elements

remove

Removes the first item from the list whose value is equal to the specified value.
Syntax: list.remove(item)

numbers = [1, 2, 3, 2]
numbers.remove(2)
print(numbers)  # Output: [1, 3, 2]

pop

Removes and returns the item at the given position. If no index is specified, it removes and returns the last item.
Syntax: list.pop([index])

numbers = [1, 2, 3]
last_item = numbers.pop()
print(last_item)  # Output: 3
print(numbers)   # Output: [1, 2]

first_item = numbers.pop(0)
print(first_item)  # Output: 1
print(numbers)     # Output: [2]

clear

Removes all items from the list.
Syntax: list.clear()

numbers = [1, 2, 3]
numbers.clear()
print(numbers)  # Output: []

Information About the List

count

Returns the number of times the specified item appears in the list.
Syntax: list.count(item)

numbers = [1, 2, 2, 3]
count_twos = numbers.count(2)
print(count_twos)  # Output: 2

index

Returns the index of the first item whose value is equal to the specified value.
Syntax: list.index(item, [start, [end]])

numbers = [1, 2, 3, 2]
index_of_two = numbers.index(2)
print(index_of_two)  # Output: 1

index_of_two_from_2 = numbers.index(2, 2)
print(index_of_two_from_2)  # Output: 3

Copying and Reversing

copy

Returns a shallow copy of the list.
Syntax: list.copy()

numbers = [1, 2, 3]
numbers_copy = numbers.copy()
print(numbers_copy)  # Output: [1, 2, 3]

reverse

Reverses the elements of the list in place.
Syntax: list.reverse()

numbers = [1, 2, 3]
numbers.reverse()
print(numbers)  # Output: [3, 2, 1]

Sorting

sort

Sorts the items of the list in place.
Syntax: list.sort(key=None, reverse=False)

numbers = [3, 1, 2]
numbers.sort()
print(numbers)  # Output: [1, 2, 3]

numbers.sort(reverse=True)
print(numbers)  # Output: [3, 2, 1]

# Sorting with a key
numbers = ["apple", "banana", "cherry"]
numbers.sort(key=len)
print(numbers)  # Output: ['apple', 'cherry', 'banana']

Tuples in Python

Tuples are a type of collection in Python that allows you to group multiple items together. Unlike lists, tuples are immutable, meaning that once they are created, their contents cannot be changed. This immutability makes tuples useful for ensuring data integrity and preventing accidental modification.

Creating Tuples

You can create a tuple by placing a comma-separated sequence of values inside parentheses.

# Creating a tuple
my_tuple = (1, 2, 3)
print(my_tuple)  # Output: (1, 2, 3)

# Tuples can also be created without parentheses
another_tuple = 4, 5, 6
print(another_tuple)  # Output: (4, 5, 6)

# Creating an empty tuple
empty_tuple = ()
print(empty_tuple)  # Output: ()

# Creating a tuple with a single item
single_item_tuple = (7,)
print(single_item_tuple)  # Output: (7,)

Accessing Tuple Elements

Elements in a tuple can be accessed using indexing, just like lists. Indices start at 0.

my_tuple = (1, 2, 3, 4, 5)

# Accessing elements
print(my_tuple[0])  # Output: 1
print(my_tuple[3])  # Output: 4

# Negative indexing
print(my_tuple[-1])  # Output: 5
print(my_tuple[-2])  # Output: 4

Slicing Tuples

You can slice tuples to create a new tuple that contains a subset of the original elements.

my_tuple = (1, 2, 3, 4, 5)

# Slicing
print(my_tuple[1:3])   # Output: (2, 3)
print(my_tuple[:2])    # Output: (1, 2)
print(my_tuple[2:])    # Output: (3, 4, 5)
print(my_tuple[-3:-1]) # Output: (3, 4)

Unpacking Tuples

Tuples can be unpacked into individual variables. The number of variables must match the number of elements in the tuple.

my_tuple = (1, 2, 3)

# Unpacking
a, b, c = my_tuple
print(a)  # Output: 1
print(b)  # Output: 2
print(c)  # Output: 3

# Unpacking with *
my_tuple = (1, 2, 3, 4, 5)
a, *b, c = my_tuple
print(a)  # Output: 1
print(b)  # Output: [2, 3, 4]
print(c)  # Output: 5

Nested Tuples

Tuples can contain other tuples as elements, creating a nested structure.

nested_tuple = (1, (2, 3), (4, (5, 6)))
print(nested_tuple)  # Output: (1, (2, 3), (4, (5, 6)))

# Accessing nested elements
print(nested_tuple[1])       # Output: (2, 3)
print(nested_tuple[2][1])    # Output: (5, 6)
print(nested_tuple[2][1][0]) # Output: 5

Tuple Operations

Tuples support various operations, such as concatenation and repetition.

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# Concatenation
concatenated_tuple = tuple1 + tuple2
print(concatenated_tuple)  # Output: (1, 2, 3, 4, 5, 6)

# Repetition
repeated_tuple = tuple1 * 2
print(repeated_tuple)  # Output: (1, 2, 3, 1, 2, 3)

Tuple Membership

You can check if an item is present in a tuple using the in keyword.

my_tuple = (1, 2, 3, 4, 5)

# Membership check
print(3 in my_tuple)  # Output: True
print(6 in my_tuple)  # Output: False

Length of a Tuple

You can find out the number of items in a tuple using the len() function.

my_tuple = (1, 2, 3, 4, 5)

# Length of the tuple
print(len(my_tuple))  # Output: 5

Tuple Immutability

Once a tuple is created, its contents cannot be modified. This immutability can be useful to ensure that the data remains unchanged throughout the program.

my_tuple = (1, 2, 3)

# Trying to change a value will raise an error
# my_tuple[0] = 4  # TypeError: 'tuple' object does not support item assignment

Tuples as Dictionary Keys

Because tuples are immutable, they can be used as keys in dictionaries, unlike lists.

my_dict = {(1, 2): "value1", (3, 4): "value2"}
print(my_dict)  # Output: {(1, 2): 'value1', (3, 4): 'value2'}

# Accessing values
print(my_dict[(1, 2)])  # Output: value1

Tuple Methods in Python

Counting Elements

count

Returns the number of times the specified item appears in the tuple.
Syntax: tuple.count(item)

my_tuple = (1, 2, 3, 2, 2, 4)
count_twos = my_tuple.count(2)
print(count_twos)  # Output: 3

Finding Index

index

Returns the index of the first item whose value is equal to the specified value.
Syntax: tuple.index(item, [start, [end]])

my_tuple = (1, 2, 3, 2, 4)
index_of_two = my_tuple.index(2)
print(index_of_two)  # Output: 1

index_of_two_from_2 = my_tuple.index(2, 2)
print(index_of_two_from_2)  # Output: 3

Dictionaries in Python

Dictionaries are a type of collection in Python that store data in key-value pairs. They are unordered, changeable, and do not allow duplicate keys. Dictionaries are optimized for retrieving data when the key is known.

Creating Dictionaries

You can create a dictionary using curly braces {} with key-value pairs separated by a colon :.

# Creating an empty dictionary
empty_dict = {}

# Creating a dictionary with some key-value pairs
my_dict = {
    "name": "John",
    "age": 30,
    "city": "New York"
}
print(my_dict)  # Output: {'name': 'John', 'age': 30, 'city': 'New York'}

# Creating a dictionary using the dict() constructor
another_dict = dict(name="Jane", age=25, city="Chicago")
print(another_dict)  # Output: {'name': 'Jane', 'age': 25, 'city': 'Chicago'}

Accessing Dictionary Elements

You can access the value associated with a specific key using square brackets [] or the get method.

my_dict = {"name": "John", "age": 30, "city": "New York"}

# Accessing values
print(my_dict["name"])  # Output: John
print(my_dict.get("age"))  # Output: 30

# Accessing a key that doesn't exist
print(my_dict.get("address"))  # Output: None

Adding and Modifying Elements

You can add new key-value pairs or modify existing ones by assigning a value to a key.

my_dict = {"name": "John", "age": 30, "city": "New York"}

# Adding a new key-value pair
my_dict["email"] = "john@example.com"
print(my_dict)  # Output: {'name': 'John', 'age': 30, 'city': 'New York', 'email': 'john@example.com'}

# Modifying an existing key-value pair
my_dict["age"] = 31
print(my_dict)  # Output: {'name': 'John', 'age': 31, 'city': 'New York', 'email': 'john@example.com'}

Removing Elements

You can remove elements from a dictionary using the del statement or the pop method.

my_dict = {"name": "John", "age": 30, "city": "New York", "email": "john@example.com"}

# Removing a key-value pair using del
del my_dict["email"]
print(my_dict)  # Output: {'name': 'John', 'age': 30, 'city': 'New York'}

# Removing a key-value pair using pop
age = my_dict.pop("age")
print(age)  # Output: 30
print(my_dict)  # Output: {'name': 'John', 'city': 'New York'}

Checking for Keys

You can check if a key exists in a dictionary using the in keyword.

my_dict = {"name": "John", "age": 30, "city": "New York"}

# Checking for a key
print("name" in my_dict)  # Output: True
print("email" in my_dict)  # Output: False

Looping Through a Dictionary

You can loop through a dictionary to access keys, values, or both.

my_dict = {"name": "John", "age": 30, "city": "New York"}

# Looping through keys
for key in my_dict:
    print(key)

# Looping through values
for value in my_dict.values():
    print(value)

# Looping through key-value pairs
for key, value in my_dict.items():
    print(key, value)

Nested Dictionaries

Dictionaries can contain other dictionaries, creating a nested structure.

nested_dict = {
    "person1": {"name": "John", "age": 30},
    "person2": {"name": "Jane", "age": 25}
}

# Accessing nested dictionary values
print(nested_dict["person1"]["name"])  # Output: John
print(nested_dict["person2"]["age"])   # Output: 25

Dictionary Comprehensions

You can create dictionaries using dictionary comprehensions, which are concise ways to generate dictionaries.

# Dictionary comprehension
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Merging Dictionaries

You can merge two dictionaries using the update method or the | operator (Python 3.9+).

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}

# Merging using update
dict1.update(dict2)
print(dict1)  # Output: {'a': 1, 'b': 3, 'c': 4}

# Merging using the | operator (Python 3.9+)
dict3 = dict1 | dict2
print(dict3)  # Output: {'a': 1, 'b': 3, 'c': 4}

Dictionary Methods in Python

Clearing and Copying

clear

Removes all elements from the dictionary.
Syntax: dictionary.clear()

my_dict = {"name": "John", "age": 30}
my_dict.clear()
print(my_dict)  # Output: {}

copy

Returns a shallow copy of the dictionary.
Syntax: dictionary.copy()

my_dict = {"name": "John", "age": 30}
copy_dict = my_dict.copy()
print(copy_dict)  # Output: {'name': 'John', 'age': 30}

Creating from Keys

fromkeys

Creates a new dictionary with keys from an iterable and values set to a specified value.
Syntax: dict.fromkeys(iterable, value=None)

keys = ('name', 'age', 'city')
value = 'unknown'
new_dict = dict.fromkeys(keys, value)
print(new_dict)  # Output: {'name': 'unknown', 'age': 'unknown', 'city': 'unknown'}

Accessing Elements

get

Returns the value for the specified key if the key is in the dictionary; otherwise, returns a default value.
Syntax: dictionary.get(key, default=None)

my_dict = {"name": "John", "age": 30}
print(my_dict.get("name"))  # Output: John
print(my_dict.get("address", "Not Found"))  # Output: Not Found

Retrieving Dictionary Views

items

Returns a view object that displays a list of a dictionary’s key-value tuple pairs.
Syntax: dictionary.items()

my_dict = {"name": "John", "age": 30}
print(my_dict.items())  # Output: dict_items([('name', 'John'), ('age', 30)])

keys

Returns a view object that displays a list of all the keys in the dictionary.
Syntax: dictionary.keys()

my_dict = {"name": "John", "age": 30}
print(my_dict.keys())  # Output: dict_keys(['name', 'age'])

values

Returns a view object that displays a list of all the values in the dictionary.
Syntax: dictionary.values()

my_dict = {"name": "John", "age": 30}
print(my_dict.values())  # Output: dict_values(['John', 30])

Removing Elements

pop

Removes the specified key and returns the corresponding value. If the key is not found, it returns a default value if provided.
Syntax: dictionary.pop(key, default=None)

my_dict = {"name": "John", "age": 30}
age = my_dict.pop("age")
print(age)  # Output: 30
print(my_dict)  # Output: {'name': 'John'}

popitem

Removes and returns the last inserted key-value pair as a tuple. It raises a KeyError if the dictionary is empty.
Syntax: dictionary.popitem()

my_dict = {"name": "John", "age": 30}
last_item = my_dict.popitem()
print(last_item)  # Output: ('age', 30)
print(my_dict)  # Output: {'name': 'John'}

Setting Default Values

setdefault

Returns the value of the specified key. If the key does not exist, inserts the key with the specified value.
Syntax: dictionary.setdefault(key, default=None)

my_dict = {"name": "John", "age": 30}
age = my_dict.setdefault("age", 25)
print(age)  # Output: 30
city = my_dict.setdefault("city", "New York")
print(city)  # Output: New York
print(my_dict)  # Output: {'name': 'John', 'age': 30, 'city': 'New York'}

Updating Dictionaries

update

Updates the dictionary with elements from another dictionary object or from an iterable of key-value pairs.
Syntax: dictionary.update([other])

my_dict = {"name": "John", "age": 30}
new_data = {"age": 31, "city": "New York"}
my_dict.update(new_data)
print(my_dict)  # Output: {'name': 'John', 'age': 31, 'city': 'New York'}

Additional Methods

len

Returns the number of key-value pairs in the dictionary.
Syntax: len(dictionary)

my_dict = {"name": "John", "age": 30}
print(len(my_dict))  # Output: 2

del

Deletes a key-value pair from the dictionary.
Syntax: del dictionary[key]

my_dict = {"name": "John", "age": 30}
del my_dict["age"]
print(my_dict)  # Output: {'name': 'John'}

Sets in Python

Sets are an unordered collection of unique items in Python. They are useful for storing elements where duplication is not allowed and for performing various mathematical set operations like union, intersection, difference, and symmetric difference.

Creating Sets

You can create a set using curly braces {} or the set() function.

# Using curly braces
my_set = {1, 2, 3}
print(my_set)  # Output: {1, 2, 3}

# Using the set() function
my_set = set([1, 2, 3])
print(my_set)  # Output: {1, 2, 3}

Adding Elements

You can add elements to a set using the add method.

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # Output: {1, 2, 3, 4}

Removing Elements

You can remove elements using the remove or discard methods. The difference is that remove will raise a KeyError if the element is not found, whereas discard will not.

my_set = {1, 2, 3}
my_set.remove(2)
print(my_set)  # Output: {1, 3}

my_set.discard(4)  # No error even if 4 is not in the set
print(my_set)  # Output: {1, 3}

Checking Membership

You can check if an element is a member of a set using the in keyword.

my_set = {1, 2, 3}
print(1 in my_set)  # Output: True
print(4 in my_set)  # Output: False

Iterating Through a Set

You can iterate through a set using a for loop.

my_set = {1, 2, 3}
for item in my_set:
    print(item)
# Output:
# 1
# 2
# 3

Set Comprehensions

Like list comprehensions, you can use set comprehensions to create sets.

my_set = {x * x for x in range(5)}
print(my_set)  # Output: {0, 1, 4, 9, 16}

Frozen Sets

A frozenset is an immutable version of a set. You can create a frozenset using the frozenset() function.

my_set = frozenset([1, 2, 3])
print(my_set)  # Output: frozenset({1, 2, 3})

Set Methods in Python

Adding Elements

add

Adds an element to the set.
Syntax: set.add(element)

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # Output: {1, 2, 3, 4}

Clearing and Copying

clear

Removes all elements from the set.
Syntax: set.clear()

my_set = {1, 2, 3}
my_set.clear()
print(my_set)  # Output: set()

copy

Returns a shallow copy of the set.
Syntax: set.copy()

my_set = {1, 2, 3}
copy_set = my_set.copy()
print(copy_set)  # Output: {1, 2, 3}

Difference and Update

difference

Returns a new set with elements that are in the set but not in another set.
Syntax: set.difference(other_set)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}
diff_set = set1.difference(set2)
print(diff_set)  # Output: {1, 2}

difference_update

Removes all elements of another set from this set.
Syntax: set.difference_update(other_set)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}
set1.difference_update(set2)
print(set1)  # Output: {1, 2}

Discarding Elements

discard

Removes an element from the set if it is a member.
Syntax: set.discard(element)

my_set = {1, 2, 3}
my_set.discard(2)
print(my_set)  # Output: {1, 3}

Intersection and Update

intersection

Returns a new set with elements that are common to this set and another.
Syntax: set.intersection(other_set)

set1 = {1, 2, 3}
set2 = {2, 3, 4}
intersection_set = set1.intersection(set2)
print(intersection_set)  # Output: {2, 3}

intersection_update

Updates the set with the intersection of itself and another.
Syntax: set.intersection_update(other_set)

set1 = {1, 2, 3}
set2 = {2, 3, 4}
set1.intersection_update(set2)
print(set1)  # Output: {2, 3}

Set Relations

isdisjoint

Returns True if two sets have no common elements.
Syntax: set.isdisjoint(other_set)

set1 = {1, 2}
set2 = {3, 4}
print(set1.isdisjoint(set2))  # Output: True

issubset

Returns True if another set contains this set.
Syntax: set.issubset(other_set)

set1 = {1, 2}
set2 = {1, 2, 3, 4}
print(set1.issubset(set2))  # Output: True

issuperset

Returns True if this set contains another set.
Syntax: set.issuperset(other_set)

set1 = {1, 2, 3, 4}
set2 = {1, 2}
print(set1.issuperset(set2))  # Output: True

Removing Elements

pop

Removes and returns an arbitrary element from the set. Raises KeyError if the set is empty.
Syntax: set.pop()

my_set = {1, 2, 3}
elem = my_set.pop()
print(elem)  # Output: 1 (this will vary as it's arbitrary)
print(my_set)  # Output: {2, 3}

remove

Removes the specified element from the set.
Syntax: set.remove(element)

my_set = {1, 2, 3}
my_set.remove(2)
print(my_set)  # Output: {1, 3}

Symmetric Difference and Update

symmetric_difference

Returns a new set with elements in either set but not both.
Syntax: set.symmetric_difference(other_set)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}
sym_diff_set = set1.symmetric_difference(set2)
print(sym_diff_set)  # Output: {1, 2, 5}

symmetric_difference_update

Updates the set with the symmetric difference of itself and another.
Syntax: set.symmetric_difference_update(other_set)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}
set1.symmetric_difference_update(set2)
print(set1)  # Output: {1, 2, 5}

Union and Update

union

Returns a new set with elements from the set and another set.
Syntax: set.union(other_set)

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set)  # Output: {1, 2, 3, 4, 5}

update

Updates the set with elements from itself and another set or iterable.
Syntax: set.update([other_set])

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.update(set2)
print(set1)  # Output: {1, 2, 3, 4, 5}

Additional Methods and Operations

Shortcut Operations (-= &= <= < >= > ^ ^= | |=)

set -= other_set: Removes all elements of other_set from set.
set &= other_set: Updates set with the intersection of itself and other_set.
set <= other_set: Returns True if every element in set is in other_set.
set < other_set: Returns True if set is a proper subset of other_set.
set >= other_set: Returns True if every element in other_set is in set.
set > other_set: Returns True if set is a proper superset of other_set.
set ^= other_set: Updates set with the symmetric difference of itself and other_set.
set |= other_set: Updates set with elements from other_set.

set1 = {1, 2, 3}
set2 = {2, 3, 4}

set1 -= {2}
print(set1)  # Output: {1, 3}

set1 &= set2
print(set1)  # Output: {3}

print(set1 <= set2)  # Output: True
print(set1 < set2)   # Output: True
print(set1 >= set2)  # Output: False
print(set1 > set2)   # Output: False

set1 ^= {3, 4, 5}
print(set1)  # Output: {4, 5}

set1 |= {1, 2}
print(set1)  # Output: {1, 2, 4, 5}

This content originally appeared on DEV Community and was authored by Harsh Mishra