Python | Modify Equal Tuple Rows

Sometimes, while working with Python Records, we can have a problem in which we need to perform the modification of element records on equality of records. This can have a problem in domains that involve data. Let's discuss certain ways in which this task can be performed.

Input : test_list = [[(12, 5)], [(13, 2)], [(6, 7)]] test_row = [(13, 2)] 
Output : [[(12, 5)], [(13, 8)], [(6, 7)]] 

Input : test_list = [[(12, 5), (7, 6)]] test_row = [(13, 2)] 
Output : [[(12, 5), (7, 6)]]

Method #1: Using loop + enumerate() 

The combination of the above functions can be used to solve this problem. In this, we apply brute force for performing task of checking for equality and performing required modification. 

# Python3 code to demonstrate working of
# Modify Equal Tuple Rows
# Using loop + enumerate()

# initializing list
test_list = [[(12, 5), (13, 6)], [(12, 2), (13, 2)]]

# printing original list
print("The original list is : " + str(test_list))

# initializing check row
test_row = [(12, 2), (13, 2)]

# Modify Equal Tuple Rows
# Using loop + enumerate()
# multiple y coordinate by 4
for idx, val in enumerate(test_list):
    if val == test_row:
        temp = []
        for sub in val:
            ele = (sub[0], sub[1] * 4)
            temp.append(ele)
        test_list[idx] = temp

# printing result
print("List after modification : " + str(test_list))

The original list is : [[(12, 5), (13, 6)], [(12, 2), (13, 2)]]
List after modification : [[(12, 5), (13, 6)], [(12, 8), (13, 8)]]

Time Complexity: O(n*n) where n is the number of elements in the list “test_list”.  loop + enumerate() performs n*n number of operations.
Auxiliary Space: O(n), extra space is required where n is the number of elements in the list.

Method #2: Using list comprehension 

This is yet another way in which this task can be performed. In this, we perform the task using list comprehension in a one-liner way similar to the above method. 

# Python3 code to demonstrate working of
# Modify Equal Tuple Rows
# Using list comprehension

# initializing list
test_list = [[(12, 5), (13, 6)], [(12, 2), (13, 2)]]

# printing original list
print("The original list is : " + str(test_list))

# initializing check row
test_row = [(12, 2), (13, 2)]

# Modify Equal Tuple Rows
# Using list comprehension
# multiple y coordinate by 4
res = [[(sub[0], sub[1] * 4) for sub in ele] if ele ==
       test_row else ele for ele in test_list]

# printing result
print("List after modification : " + str(res))

The original list is : [[(12, 5), (13, 6)], [(12, 2), (13, 2)]]
List after modification : [[(12, 5), (13, 6)], [(12, 8), (13, 8)]]

Method 3: Using the map() function with lambda function

• The program then applies the map() function, along with a lambda function, to modify the equal tuple rows in the "test_list" by multiplying the second element of the tuples by 4. The lambda function checks if the current sublist is equal to the "test_row" variable. If it is, then it applies a list comprehension to the sublist, which multiplies the second element of each tuple by 4, and returns the modified sublist. Otherwise, it returns the original sublist.
• The modified list is then stored in a variable named "res".
• Finally, the program prints the modified list using the print() function.

# Python3 code to demonstrate working of
# Modify Equal Tuple Rows
# Using map() + lambda function

# initializing list
test_list = [[(12, 5), (13, 6)], [(12, 2), (13, 2)]]

# printing original list
print("The original list is : " + str(test_list))

# initializing check row
test_row = [(12, 2), (13, 2)]

# Modify Equal Tuple Rows
# Using map() + lambda function
res = list(map(lambda ele: [(sub[0], sub[1] * 4)
                            for sub in ele] if ele == test_row else ele, test_list))

# printing result
print("List after modification : " + str(res))

The original list is : [[(12, 5), (13, 6)], [(12, 2), (13, 2)]]
List after modification : [[(12, 5), (13, 6)], [(12, 8), (13, 8)]]

Time complexity: O(nm) where n is the number of rows and m is the number of tuples in each row. 
Auxiliary space: O(nm) for creating the new list of modified rows.

Method 4: Using the NumPy library. 

Step-by-step approach:

• Import the NumPy library using the import statement.
• Convert the test_list to a NumPy array using the np.array() method.
• Use the np.where() method to compare each row of the NumPy array with the test_row.
• If the rows are equal, modify the second element of each tuple in the row using the np.multiply() method and the broadcasted test_row tuple.
• Convert the modified NumPy array back to a list of tuples using the np.ndarray.tolist() method.

import numpy as np

# initializing list
test_list = [[(12, 5), (13, 6)], [(12, 2), (13, 2)]]

# printing original list
print("The original list is : " + str(test_list))

# initializing check row
test_row = [(12, 2), (13, 2)]

# Using NumPy library
# Convert to numpy array
np_array = np.array(test_list)

# Use np.where() to compare rows with test_row
# If equal, modify the second element of each tuple in the row
# using np.multiply() and the broadcasted test_row tuple
np_array = np.where(np_array == np.array(test_row),
                    np.multiply(np_array, np.broadcast_to([1, 4], np_array.shape)),
                    np_array)

# Convert modified NumPy array back to a list of tuples
res = np_array.tolist()

# printing result
print("List after modification : " + str(res))

Output:

The original list is : [[(12, 5), (13, 6)], [(12, 2), (13, 2)]]
List after modification : [[[12, 5], [13, 6]], [[12, 8], [13, 8]]]

Time complexity: O(nm), where n is the number of sublists and m is the number of tuples in each sublist.
Auxiliary space: O(nm), as we create a NumPy array to store the list and perform element-wise comparisons and modifications on the NumPy array.

manjeet_04

Follow

Improve

Article Tags :

• Python
• Python list-programs

Practice Tags :

• python