Python Collections
Tags: python, programming, beginners, tutorial
Published: 2024-06-27 11:58:50

### 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 `[]`.

```python
# 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.

```python
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.

```python
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]`.

```python
# 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.

```python
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.

```python
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.

```python
# 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.

```python
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.

```python
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.

```python
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.

```python
# 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.

```python
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.

```python
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)`

```python
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)`

```python
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)`

```python
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)`

```python
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])`

```python
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()`

```python
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)`

```python
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]])`

```python
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()`

```python
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()`

```python
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)`

```python
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.

```python
# 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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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)`

```python
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]])`

```python
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 `:`.

```python
# 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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
# 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+).

```python
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()`

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

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

```python
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)`

```python
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)`

```python
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()`

```python
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()`

```python
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()`

```python
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)`

```python
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()`

```python
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)`

```python
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])`

```python
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)`

```python
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]`

```python
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.

```python
# 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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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.

```python
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)`

```python
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()`

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

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

```python
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)`

```python
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)`

```python
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)`

```python
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)`

```python
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)`

```python
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)`

```python
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)`

```python
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)`

```python
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()`

```python
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)`

```python
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)`

```python
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)`

```python
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)`

```python
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])`

```python
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`.

```python
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}
```