Lists, Tuples, Sets, Dictionaries
In this article, we'll learn everything about Python lists, how they are created, slicing of a list, adding or removing elements from them and so on. List is one of the most frequently used and very versatile data types used in Python.
In Python programming, a list is created by placing all the items (elements) inside square brackets [] , separated by commas.
It can have any number of items and they may be of different types (integer, float, string etc.)
A list can also have another list as an item. This is called a nested list.
How to access elements from a list?
There are various ways in which we can access the elements of a list
We can use the index operator [] to access an item in a list. In Python, indices start at 0. So, a list having 5 elements will have an index from 0 to 4.
Trying to access indexes other than these will raise an IndexError . The index must be an integer. We can't use float or other types, this will result in TypeError.
Nested lists are accessed using nested indexing.
my_list = ['p', 'r', 'o', 'b', 'e']
n_list = ["Happy", [2, 0, 1, 5]]
# Error! Only integer can be used for indexing
Traceback (most recent call last):
File "<string>", line 21, in <module>
TypeError: list indices must be integers or slices, not float
Python allows negative indexing for its sequences. The index of -1 refers to the last item, -2 to the second last item and so on.
# Negative indexing in lists
my_list = ['p','r','o','b','e']
How to slice lists in Python?
We can access a range of items in a list by using the slicing operator : (colon).
my_list = ['p','r','o','g','r','a','m','i','z']
# elements beginning to 4th
# elements beginning to end
['p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z']
Slicing can be best visualized by considering the index to be between the elements as shown below. So if we want to access a range, we need two indices that will slice that portion from the list.
Lists are mutable, meaning their elements can be changed unlike string or tuple.
We can use the assignment operator ( = ) to change an item or a range of items.
# Correcting mistake values in a list
# change 2nd to 4th items
We can add one item to a list using the append() method or add several items using extend() method.
# Appending and Extending lists in Python
We can also use + operator to combine two lists. This is also called concatenation.
The * operator repeats a list for the given number of times.
# Concatenating and repeating lists
Furthermore, we can insert one item at a desired location by using the method insert() or insert multiple items by squeezing it into an empty slice of a list.
# Demonstration of list insert() method
Delete/Remove List Elements
We can delete one or more items from a list using the keyword del . It can even delete the list entirely
my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']
# Error: List not defined
['p', 'r', 'b', 'l', 'e', 'm']
Traceback (most recent call last):
File "<string>", line 18, in <module>
NameError: name 'my_list' is not defined
We can use remove() method to remove the given item or pop() method to remove an item at the given index.
The pop() method removes and returns the last item if the index is not provided. This helps us implement lists as stacks (first in, last out data structure).
We can also use the clear() method to empty a list.
my_list = ['p','r','o','b','l','e','m']
# Output: ['r', 'o', 'b', 'l', 'e', 'm']
# Output: ['r', 'b', 'l', 'e', 'm']
# Output: ['r', 'b', 'l', 'e']
['r', 'o', 'b', 'l', 'e', 'm']
['r', 'b', 'l', 'e', 'm']
Finally, we can also delete items in a list by assigning an empty list to a slice of elements.
>>> my_list = ['p','r','o','b','l','e','m']
['p', 'r', 'b', 'l', 'e', 'm']
Some examples of Python list methods:
my_list = [3, 8, 1, 6, 0, 8, 4]
# Output: [0, 1, 3, 4, 6, 8, 8]
# Output: [8, 8, 6, 4, 3, 1, 0]
List Comprehension: Elegant way to create Lists
List comprehension is an elegant and concise way to create a new list from an existing list in Python.
A list comprehension consists of an expression followed by
inside square brackets.
Here is an example to make a list with each item being increasing power of 2.
pow2 = [2 ** x for x in range(10)]
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
This code is equivalent to:
A list comprehension can optionally contain more for or
. An optional if statement can filter out items for the new list. Here are some examples.
>>> pow2 = [2 ** x for x in range(10) if x > 5]
>>> odd = [x for x in range(20) if x % 2 == 1]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> [x+y for x in ['Python ','C '] for y in ['Language','Programming']]
['Python Language', 'Python Programming', 'C Language', 'C Programming']
Other List Operations in Python
We can test if an item exists in a list or not, using the keyword in.
my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']
print('c' not in my_list)
Using a for loop we can iterate through each item in a list.
for fruit in ['apple','banana','mango']:
In this article, you'll learn everything about Python tuples. More specifically, what are tuples, how to create them, when to use them and various methods you should be familiar with.
A tuple in Python is similar to a list. The difference between the two is that we cannot change the elements of a tuple once it is assigned whereas we can change the elements of a list.
A tuple is created by placing all the items (elements) inside parentheses () , separated by commas. The parentheses are optional, however, it is a good practice to use them.
A tuple can have any number of items and they may be of different types (integer, float, list, string, etc.).
# Different types of tuples
# tuple with mixed datatypes
my_tuple = (1, "Hello", 3.4)
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
('mouse', [8, 4, 6], (1, 2, 3))
A tuple can also be created without using parentheses. This is known as tuple packing.
# tuple unpacking is also possible
Creating a tuple with one element is a bit tricky.
Having one element within parentheses is not enough. We will need a trailing comma to indicate that it is, in fact, a tuple.
print(type(my_tuple)) # <class 'str'>
# Creating a tuple having one element
print(type(my_tuple)) # <class 'tuple'>
# Parentheses is optional
print(type(my_tuple)) # <class 'tuple'>
There are various ways in which we can access the elements of a tuple.
We can use the index operator [] to access an item in a tuple, where the index starts from 0.
So, a tuple having 6 elements will have indices from 0 to 5. Trying to access an index outside of the tuple index range(6,7,... in this example) will raise an IndexError .
The index must be an integer, so we cannot use float or other types. This will result in TypeError .
Likewise, nested tuples are accessed using nested indexing, as shown in the example below.
# Accessing tuple elements using indexing
my_tuple = ('p','e','r','m','i','t')
# IndexError: list index out of range
# Index must be an integer
# TypeError: list indices must be integers, not float
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(n_tuple[0][3]) # 's'
Python allows negative indexing for its sequences.
The index of -1 refers to the last item, -2 to the second last item and so on.
# Negative indexing for accessing tuple elements
my_tuple = ('p', 'e', 'r', 'm', 'i', 't')
We can access a range of items in a tuple by using the slicing operator colon:
# Accessing tuple elements using slicing
my_tuple = ('p','r','o','g','r','a','m','i','z')
# Output: ('r', 'o', 'g')
# elements beginning to 2nd
# elements beginning to end
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
Slicing can be best visualized by considering the index to be between the elements as shown below. So if we want to access a range, we need the index that will slice the portion from the tuple.
Unlike lists, tuples are immutable.
This means that elements of a tuple cannot be changed once they have been assigned. But, if the element is itself a mutable data type like list, its nested items can be changed.
We can also assign a tuple to different values (reassignment).
my_tuple = (4, 2, 3, [6, 5])
# TypeError: 'tuple' object does not support item assignment
# However, item of mutable element can be changed
my_tuple[3][0] = 9 # Output: (4, 2, 3, [9, 5])
# Tuples can be reassigned
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
We can use + operator to combine two tuples. This is called concatenation .
We can also repeat the elements in a tuple for a given number of times using the operator.
Both + and operations result in a new tuple
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))
# Output: ('Repeat', 'Repeat', 'Repeat')
('Repeat', 'Repeat', 'Repeat')
As discussed above, we cannot change the elements in a tuple. It means that we cannot delete or remove items from a tuple.
Deleting a tuple entirely, however, is possible using the keyword del .
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# TypeError: 'tuple' object doesn't support item deletion
# Can delete an entire tuple
# NameError: name 'my_tuple' is not defined
Traceback (most recent call last):
File "<string>", line 12, in <module>
NameError: name 'my_tuple' is not defined
Methods that add items or remove items are not available with tuple. Only the following two methods are available.
Some examples of Python tuple methods:
my_tuple = ('a', 'p', 'p', 'l', 'e',)
print(my_tuple.count('p')) # Output: 2
print(my_tuple.index('l')) # Output: 3
We can test if an item exists in a tuple or not, using the keyword in
# Membership test in tuple
my_tuple = ('a', 'p', 'p', 'l', 'e',)
print('g' not in my_tuple)
2. Iterating Through a Tuple
We can use a for loop to iterate through each item in a tuple.
# Using a for loop to iterate through a tuple
for name in ('John', 'Kate'):
Advantages of Tuple over List
Since tuples are quite similar to lists, both of them are used in similar situations. However, there are certain advantages of implementing a tuple over a list. Below listed are some of the main advantages:
We generally use tuples for heterogeneous (different) data types and lists for homogeneous (similar) data types.
Since tuples are immutable, iterating through a tuple is faster than with list. So there is a slight performance boost.
Tuples that contain immutable elements can be used as a key for a dictionary. With lists, this is not possible.
If you have data that doesn't change, implementing it as tuple will guarantee that it remains write-protected.
In this tutorial, you'll learn everything about Python sets; how they are created, adding or removing elements from them, and all operations performed on sets in Python.
A set is an unordered collection of items. Every set element is unique (no duplicates) and must be immutable (cannot be changed).
However, a set itself is mutable. We can add or remove items from it.
Sets can also be used to perform mathematical set operations like union, intersection, symmetric difference, etc.
A set is created by placing all the items (elements) inside curly braces {}, separated by comma, or by using the built-in set() function.
It can have any number of items and they may be of different types (integer, float, tuple, string etc.). But a set cannot have mutable elements like
, sets or
as its elements.
# Different types of sets in Python
my_set = {1.0, "Hello", (1, 2, 3)}
{1.0, (1, 2, 3), 'Hello'}
Try the following examples as well.
# set cannot have duplicates
my_set = {1, 2, 3, 4, 3, 2}
# we can make set from a list
my_set = set([1, 2, 3, 2])
# set cannot have mutable items
# here [3, 4] is a mutable list
# this will cause an error.
Traceback (most recent call last):
File "<string>", line 15, in <module>
TypeError: unhashable type: 'list'
Creating an empty set is a bit tricky.
Empty curly braces {} will make an empty dictionary in Python. To make a set without any elements, we use the set() function without any argument.
# Distinguish set and dictionary while creating empty set
# initialize a with set()
Modifying a set in Python
Sets are mutable. However, since they are unordered, indexing has no meaning.
We cannot access or change an element of a set using indexing or slicing. Set data type does not support it.
We can add a single element using the add() method, and multiple elements using the update() method. The update() method can take tuples, lists, strings or other sets as its argument. In all cases, duplicates are avoided.
# if you uncomment the above line
# TypeError: 'set' object does not support indexing
# Output: {1, 2, 3, 4, 5, 6, 8}
my_set.update([4, 5], {1, 6, 8})
Removing elements from a set
A particular item can be removed from a set using the methods discard() and remove().
The only difference between the two is that the discard() function leaves a set unchanged if the element is not present in the set. On the other hand, the remove() function will raise an error in such a condition (if element is not present in the set).
The following example will illustrate this.
# Difference between discard() and remove()
Traceback (most recent call last):
File "<string>", line 28, in <module>
Similarly, we can remove and return an item using the pop() method.
Since set is an unordered data type, there is no way of determining which item will be popped. It is completely arbitrary.
We can also remove all the items from a set using the clear() method.
# Output: set of unique elements
my_set = set("HelloWorld")
{'H', 'l', 'r', 'W', 'o', 'd', 'e'}
{'r', 'W', 'o', 'd', 'e'}
Sets can be used to carry out mathematical set operations like union, intersection, difference and symmetric difference. We can do this with operators or methods.
Let us consider the following two sets for the following operations.
Union of A and B is a set of all elements from both sets.
Union is performed using | operator. Same can be accomplished using the union() method.
# Output: {1, 2, 3, 4, 5, 6, 7, 8}
Try the following examples on Python shell.
# use union function on B
Intersection of A and B is a set of elements that are common in both the sets.
Intersection is performed using & operator. Same can be accomplished using the intersection() method.
Try the following examples on Python shell.
# use intersection function on A
# use intersection function on B
Difference of the set B from set A(A - B) is a set of elements that are only in A but not in B. Similarly, B - A is a set of elements in B but not in A.
Difference is performed using - operator. Same can be accomplished using the difference() method
Try the following examples on Python shell
# use difference function on A
# use difference function on B
Symmetric Difference of A and B is a set of elements in A and B but not in both (excluding the intersection).
Symmetric difference is performed using ^ operator. Same can be accomplished using the method symmetric_difference() .
# Symmetric difference of two sets
# Output: {1, 2, 3, 6, 7, 8}
Try the following examples on Python shell.
# use symmetric_difference function on A
>>> A.symmetric_difference(B)
# use symmetric_difference function on B
>>> B.symmetric_difference(A)
There are many set methods, some of which we have already used above. Here is a list of all the methods that are available with the set objects:
We can test if an item exists in a set or not, using the in keyword
# check if 'a' is present
# check if 'p' is present
We can iterate through each item in a set using a for loop.
>>> for letter in set("apple"):
Built-in Functions with Set
Built-in functions like all(), any(), enumerate(), len(), max(), min(), sorted(), sum() etc. are commonly used with sets to perform different tasks.
Frozenset is a new class that has the characteristics of a set, but its elements cannot be changed once assigned. While tuples are immutable lists, frozensets are immutable sets.
Sets being mutable are unhashable, so they can't be used as dictionary keys. On the other hand, frozensets are hashable and can be used as keys to a dictionary.
Frozensets can be created using the
function.
This data type supports methods like copy(), difference(), intersection(), isdisjoint(), issubset(), issuperset(), symmetric_difference() and union(). Being immutable, it does not have methods that add or remove elements.
A = frozenset([1, 2, 3, 4])
B = frozenset([3, 4, 5, 6])
Try these examples on Python shell.
frozenset({1, 2, 3, 4, 5, 6})
AttributeError: 'frozenset' object has no attribute 'add'
In this tutorial, you'll learn everything about Python dictionaries; how they are created, accessing, adding, removing elements from them and various built-in methods.
Python dictionary is an unordered collection of items. Each item of a dictionary has a key/value pair.
Dictionaries are optimized to retrieve values when the key is known.
Creating Python Dictionary
Creating a dictionary is as simple as placing items inside curly braces {} separated by commas.
An item has a key and a corresponding value that is expressed as a pair ( key: value ).
While the values can be of any data type and can repeat, keys must be of immutable type (string, number or tuple with immutable elements) and must be unique
# dictionary with integer keys
my_dict = {1: 'apple', 2: 'ball'}
# dictionary with mixed keys
my_dict = {'name': 'John', 1: [2, 4, 3]}
my_dict = dict({1:'apple', 2:'ball'})
# from sequence having each item as a pair
my_dict = dict([(1,'apple'), (2,'ball')])
As you can see from above, we can also create a dictionary using the built-in dict() function.
Accessing Elements from Dictionary
While indexing is used with other data types to access values, a dictionary uses keys . Keys can be used either inside square brackets [] or with the get() method.
If we use the square brackets [] , KeyError is raised in case a key is not found in the dictionary. On the other hand, the get() method returns None if the key is not found.
# get vs [] for retrieving elements
my_dict = {'name': 'Jack', 'age': 26}
print(my_dict.get('age'))
# Trying to access keys which doesn't exist throws error
print(my_dict.get('address'))
print(my_dict['address'])
Traceback (most recent call last):
File "<string>", line 15, in <module>
print(my_dict['address'])
Changing and Adding Dictionary elements
Dictionaries are mutable. We can add new items or change the value of existing items using an assignment operator.
If the key is already present, then the existing value gets updated. In case the key is not present, a new ( key: value ) pair is added to the dictionary.
# Changing and adding Dictionary Elements
my_dict = {'name': 'Jack', 'age': 26}
#Output: {'age': 27, 'name': 'Jack'}
my_dict['address'] = 'Downtown'
# Output: {'address': 'Downtown', 'age': 27, 'name': 'Jack'}
{'name': 'Jack', 'age': 27}
{'name': 'Jack', 'age': 27, 'address': 'Downtown'}
Removing elements from Dictionary
We can remove a particular item in a dictionary by using the pop() method. This method removes an item with the provided key and returns the value .
The popitem() method can be used to remove and return an arbitrary (key, value) item pair from the dictionary. All the items can be removed at once, using the clear() method.
We can also use the del keyword to remove individual items or the entire dictionary itself.
# Removing elements from a dictionary
squares = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# remove a particular item, returns its value
# Output: {1: 1, 2: 4, 3: 9, 5: 25}
# remove an arbitrary item, return (key,value)
# Output: {1: 1, 2: 4, 3: 9}
# delete the dictionary itself
{1: 1, 2: 4, 3: 9, 5: 25}
Traceback (most recent call last):
File "<string>", line 30, in <module>
NameError: name 'squares' is not defined
Python Dictionary Methods
Methods that are available with a dictionary are tabulated below. Some of them have already been used in the above examples.
Here are a few example use cases of these methods.
marks = {}.fromkeys(['Math', 'English', 'Science'], 0)
# Output: {'English': 0, 'Math': 0, 'Science': 0}
for item in marks.items():
# Output: ['English', 'Math', 'Science']
print(list(sorted(marks.keys())))
{'Math': 0, 'English': 0, 'Science': 0}
['English', 'Math', 'Science']
Python Dictionary Comprehension
Dictionary comprehension is an elegant and concise way to create a new dictionary from an iterable in Python.
Dictionary comprehension consists of an expression pair (key: value) followed by a for statement inside curly braces {}.
Here is an example to make a dictionary with each item being a pair of a number and its square.
# Dictionary Comprehension
squares = {x: x*x for x in range(6)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
This code is equivalent to
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
A dictionary comprehension can optionally contain more
or
statements.
An optional if statement can filter out items to form the new dictionary.
Here are some examples to make a dictionary with only odd items.
# Dictionary Comprehension with if conditional
odd_squares = {x: x*x for x in range(11) if x % 2 == 1}
{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
Other Dictionary Operations
Dictionary Membership Test
We can test if a key is in a dictionary or not using the keyword in. Notice that the membership test is only for the keys and not for the values.
# Membership Test for Dictionary Keys
squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
# membership tests for key only not value
Iterating Through a Dictionary
We can iterate through each key in a dictionary using a for loop.
# Iterating through a Dictionary
squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
Dictionary Built-in Functions
Built-in functions like all(), any(), len(), cmp(), sorted(), etc. are commonly used with dictionaries to perform different tasks.
Here are some examples that use built-in functions to work with a dictionary.
# Dictionary Built-in Functions
squares = {0: 0, 1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
# Output: [0, 1, 3, 5, 7, 9]
Last updated