Sometimes, while working with Python list, we can have a problem in which we need to add a new tuple to existing list. Append at rear is usually easier than addition at front. Let’s discuss certain ways in which this task can be performed.
Method #1 : Using insert() This is one of the way in which the element can be added to rear in one-liner. It is used to add any element in rear of list. The behaviour is the same for tuple as well.
Python3
# Python3 code to demonstrate working of# Rear Addition of Record# using insert()# Initializing list test_list = [('is', 2), ('best', 3)]# printing original list print("The original list is : " + str(test_list))# Initializing tuple to add add_tuple = ('gfg', 1)# Rear Addition of Record# using insert()test_list.insert(len(test_list), add_tuple)# printing resultprint("The tuple after adding is : " + str(test_list)) |
The original list is : [('is', 2), ('best', 3)]
The tuple after adding is : [('is', 2), ('best', 3), ('gfg', 1)]
Time Complexity: O(1) as the insert() method takes constant time for adding the element at the rear end.
Auxiliary Space: O(1) as the size of the list is not increasing, only the reference to the list is changing.
Method #2 : Using deque() + append() The combination of above functions can be used to perform this particular task. In this, we just need to convert the list into a deque so that we can perform the append at right using append().
Python3
# Python3 code to demonstrate working of# Rear Addition of Record# using deque() + append()from collections import deque# Initializing listtest_list = [('is', 2), ('best', 3)]# printing original listprint("The original list is : " + str(test_list))# Initializing tuple to addadd_tuple = ('gfg', 1)# Rear Addition of Record# using deque() + append()res = deque(test_list)res.append(add_tuple)# printing resultprint("The tuple after adding is : " + str(list(res))) |
The original list is : [('is', 2), ('best', 3)]
The tuple after adding is : [('is', 2), ('best', 3), ('gfg', 1)]
Time Complexity: O(1)
Auxiliary Space: O(n) where n is the size of the list or the number of elements in the list.
Method #3 : Using extend() method
Python3
# Python3 code to demonstrate working of# Rear Addition of Record# Initializing listtest_list = [('is', 2), ('best', 3)]# printing original listprint("The original list is : " + str(test_list))# Initializing tuple to addadd_tuple = ('gfg', 1)# Rear Addition of Recordtest_list.extend([add_tuple])# printing resultprint("The tuple after adding is : " + str(test_list)) |
The original list is : [('is', 2), ('best', 3)]
The tuple after adding is : [('is', 2), ('best', 3), ('gfg', 1)]
Time complexity: O(1)
Auxiliary Space: O(n) where n is the size of the test_list.
Method 4: Using the + operator to concatenate two lists
Step-by-step approach:
- Initialize the list with tuple elements.
- Create a new list containing the tuple to add.
- Concatenate the two lists using the + operator.
- Assign the concatenated list to the original list variable.
- Print the modified list.
Python3
# Python3 code to demonstrate working of# Rear Addition of Record# Initializing listtest_list = [('is', 2), ('best', 3)]# printing original listprint("The original list is : " + str(test_list))# Initializing tuple to addadd_tuple = ('gfg', 1)# Rear Addition of Recordnew_list = [add_tuple]test_list = test_list + new_list# printing resultprint("The tuple after adding is : " + str(test_list)) |
The original list is : [('is', 2), ('best', 3)]
The tuple after adding is : [('is', 2), ('best', 3), ('gfg', 1)]
Time Complexity: O(n), where n is the length of the original list.
Auxiliary Space: O(n), where n is the length of the original list.
METHOD 5: Using list comprehension
APPROACH:
This Python program adds a new key-value tuple to a list of key-value tuples. The program uses a list comprehension to concatenate the original list and the new tuple. The new list is then displayed.
ALGORITHM:
1.Initialize the original list with key-value pairs.
2.Create a new tuple with the key-value pair to be added.
3.Use a list comprehension to concatenate the original list and the new tuple.
4.Display the new list.
Python3
original_list = [('is', 2), ('best', 3)]new_tuple = ('gfg', 1)new_list = [item for item in original_list] + [new_tuple]print("The tuple after adding is:", new_list) |
The tuple after adding is: [('is', 2), ('best', 3), ('gfg', 1)]
Time complexity: O(n), where n is the length of the original list.
Space complexity: O(n)
METHOD 6: Using heapq:
Algorithm:
- Initialize the original list test_list and the tuple to be added add_tuple.
- Print the original list.
- Add the add_tuple to the test_list using heapq.heappush() method.
- Convert the test_list heap back to a list using the list() method.
- Print the updated list.
Python3
import heapq# Initializing listtest_list = [('is', 2), ('best', 3)]# printing original listprint("The original list is : " + str(test_list))# Initializing tuple to addadd_tuple = ('gfg', 1)# Add the tuple to the list using heapqheapq.heappush(test_list, add_tuple)# Convert the heap back to a listres = list(test_list)# printing resultprint("The tuple after adding is : " + str(res))#This code is contributed by Jyothi pinjala. |
The original list is : [('is', 2), ('best', 3)]
The tuple after adding is : [('gfg', 1), ('best', 3), ('is', 2)]
Time Complexity:
The time complexity of heappush() method is O(log n) where n is the number of elements in the heap. In this case, we are adding only one element to the heap, so the time complexity would be O(log 2) which is a constant time operation.
Converting the heap back to a list takes O(n) time complexity, where n is the number of elements in the heap.
Space Complexity:
The space complexity of the algorithm is O(n) where n is the number of elements in the heap. This is because heappush() method creates a heap data structure which takes O(n) space. However, since we are adding only one element to the heap, the actual space used in this case would be very small. Additionally, the space used by the list is also O(n).
