Table of contents
Welcome to Day 7 of our Python blog series! Today, we'll explore two fundamental data structures in Python: lists and tuples. Lists and tuples are both sequence data types that can store multiple elements, but they have some key differences in terms of mutability and syntax. Let's dive in and learn more about working with lists and tuples:
Lists
A list in Python is a mutable, ordered collection of elements enclosed within square brackets ([]). Lists can contain elements of different data types, and you can modify them after creation.
List Operations
Accessing Elements: You can access elements of a list using indexing and slicing.
num = [1, 2, 3, 4, 5]
#Accessing the first element
first_element = num[0] # 1
#Accessing a range of elements
subset = num[1:4] # [2, 3, 4]
Modifying Elements: Lists are mutable, so you can modify elements by assigning new values.
num = [1, 2, 3, 4, 5]
#Modifying the second element
num[1] = 10
#Result: [1, 10, 3, 4, 5]
Adding & Removing Elements: You can append elements to the end of a list using the append() method, or insert elements at specific positions using the insert() method. Using the remove() method, by index using the pop() method, or by slicing you can remove elements
num = [1, 2, 3]
#Appending an element
num.append(4)
#Result: [1, 2, 3, 4]
#Inserting an element at index 1
num.insert(1, 5)
#Result: [1, 5, 2, 3, 4]
# Removing an element by value
num.remove(3)
#Result: [1, 2, 4, 5]
# Removing an element by index
popped_element = num.pop(2)
# Result: [1, 2, 5], popped_element = 4
Combining Lists: You can concatenate lists using the + operator or extend a list with another list using the extend() method.
list1 = [1, 2, 3]
list2 = [4, 5, 6]
#Concatenating lists
combined = list1 + list2
#Result: [1, 2, 3, 4, 5, 6]
#Extending list1 with list2
list1.extend(list2)
#Result: list1 = [1, 2, 3, 4, 5, 6]
Tuples
A tuple in Python is an immutable, ordered collection of elements enclosed within parentheses (). Tuples are similar to lists but cannot be modified after creation.
Tuple Operations
Accessing Elements:
You can access elements of a tuple using indexing and slicing, similar to lists.
tuple_ = (10, 20, 30)
# Accessing the first element
first_element = tuple_[0] # 10
# Accessing a range of elements
subset = tuple_[1:3] # (20, 30)
Concatenation of Tuples:
Concatenating tuples involves creating a new tuple by combining the elements of two or more existing tuples. You can achieve tuple concatenation using the + operator.
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
#Concatenating tuples
concatenated_tuple = tuple1 + tuple2
#Result: (1, 2, 3, 4, 5, 6)
Deleting a Tuple:
In Python, tuples are immutable, meaning their elements cannot be modified, added, or removed after the tuple is created. However, you can delete an entire tuple object using the del statement. Here's how you can delete a tuple:
tuple1 = (1, 2, 3)
#Deleting the tuple
del tuple1
Conclusion
Lists and tuples are both sequence data types in Python and share several similarities:
Ordered Collection: Both lists and tuples maintain the order of elements, meaning the elements are stored and accessed in the same order in which they are defined.
Indexing and Slicing: You can access elements of both lists and tuples using indexing and slicing notation.
Iterable: Both lists and tuples are iterable, meaning you can loop over their elements using a
forloop.Contain Duplicate Elements: Both lists and tuples can contain duplicate elements.
However, there is one key difference between lists and tuples:
Mutability: Lists are mutable, meaning you can modify their elements (add, remove, or change elements) after creation. Tuples, on the other hand, are immutable, meaning once a tuple is created, its elements cannot be modified, added, or removed.