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 ofother_set
fromset
. -
set &= other_set
: Updatesset
with the intersection of itself andother_set
. -
set <= other_set
: Returns True if every element inset
is inother_set
. -
set < other_set
: Returns True ifset
is a proper subset ofother_set
. -
set >= other_set
: Returns True if every element inother_set
is inset
. -
set > other_set
: Returns True ifset
is a proper superset ofother_set
. -
set ^= other_set
: Updatesset
with the symmetric difference of itself andother_set
. -
set |= other_set
: Updatesset
with elements fromother_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}