Sometimes, while working with records, we can have a problem in which any element of record can be of type string but mistakenly processed as list of characters. This can be a problem while working with a lot of data. Let's discuss certain ways in which this problem can be solved.
Method #1: Using list comprehension + join()
The combination of above functionalities can be used to achieve the solution of above task. In this, we get the character list using list comprehension and conversion task is performed by join().
Python3
# Python3 code to demonstrate working of
# Merge Tuple String List values to String
# using list comprehension + join()
# initialize list
test_list = [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)]
# printing original list
print("The original list : " + str(test_list))
# Merge Tuple String List values to String
# using list comprehension + join()
res = [''.join(i) for i, j in test_list]
# printing result
print("The joined character list tuple element to string is : " + str(res))
Output :
The original list : [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)] The joined character list tuple element to string is : ['gfg', 'is', 'best']
Time complexity: O(n * m), where n is the length of the input list and m is the maximum length of any tuple in the list.
Auxiliary Space: O(n *m), as the new list created by the list comprehension has the same length and maximum element size as the input list.
Method #2: Using map() + join() + lambda The task performed by list comprehension in the above method can be performed by map() and lambda function can be used to construct the logic to achieve the solution to this task.
Python3
# Python3 code to demonstrate working of
# Merge Tuple String List values to String
# using map() + join() + lambda
# initialize list
test_list = [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)]
# printing original list
print("The original list : " + str(test_list))
# Merge Tuple String List values to String
# using map() + join() + lambda
res = list(map(lambda sub: "".join(sub[0]), test_list))
# printing result
print("The joined character list tuple element to string is : " + str(res))
Output :
The original list : [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)] The joined character list tuple element to string is : ['gfg', 'is', 'best']
The time complexity of this code is O(n), where n is the length of the input list test_list.
The space complexity of this code is O(n), where n is the length of the input list test_list.
Method #3: Using a for loop
Iterates over each tuple in test_list, joins its first element (a list of strings), and appends the resulting string to the res list. Finally, it prints the result.
Python3
test_list = [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)]
res = []
for sub in test_list:
res.append(''.join(sub[0]))
print("The joined character list tuple element to string is : " + str(res))
OutputThe joined character list tuple element to string is : ['gfg', 'is', 'best']
The time complexity of this code is O(n*m), where n is the length of the test_list and m is the maximum length of the sub-lists in test_list.
The space complexity of this code is also O(nm), because it creates a new list res to store the concatenated strings.
Method 4: Using a generator expression
We can also solve this problem using a generator expression, which is similar to a list comprehension but doesn't create a list in memory. This can be more memory-efficient for large input lists.
Follow the below steps to implement the above idea:
- Defining a list called test_list. This list contains three tuple elements, where each tuple contains a list of strings and an integer value.
- Create a generator expression using a for loop that iterates over each tuple element in test_list. Inside the for loop, use the join() method to concatenate all the strings in the current list element of the tuple.
- Assign this generator expression to a variable called res. The generator expression returns an iterable that yields the concatenated strings for each tuple in test_list.
- Finally, print the result by converting the generator expression to a list using the list() function and then converting it to a string. Concatenate the string with a message that explains what the program does.
Python3
test_list = [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)]
res = (''.join(i) for i, j in test_list)
print("The joined character list tuple element to string is : " + str(list(res)))
OutputThe joined character list tuple element to string is : ['gfg', 'is', 'best']
Time Complexity: O(n*m).where n is the number of tuples in test_list and m is the maximum length of the string list in each tuple.
Auxiliary Space: O(n*m).where n is the number of tuples in test_list and m is the maximum length of the string list in each tuple.
Method 5: Using reduce() function
- Import the reduce() function from the functools module.
- Initialize the input list with tuples containing string lists and integer values.
- Define a lambda function to concatenate the string lists in each tuple.
- Use the reduce() function with the lambda function to apply the concatenation operation on each tuple and return a new list containing the concatenated string values.
Python3
from functools import reduce
# initialize list
test_list = [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)]
# printing original list
print("The original list : " + str(test_list))
# Merge Tuple String List values to String using reduce() function
res = reduce(lambda x, y: x + [''.join(y[0])], test_list, [])
# printing result
print("The joined character list tuple element to string is : " + str(res))
OutputThe original list : [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)]
The joined character list tuple element to string is : ['gfg', 'is', 'best']
Time complexity: O(n), where n is the number of tuples in the input list.
Auxiliary space: O(n), where n is the number of tuples in the input list.
Method 6: Using a nested for loop and join()
Step-by-step approach :
- Initializing an empty list res to store our results.
- Loop over each tuple in the test_list using a for a loop.
- Initialize an empty string.
- Loop over each character in the first element of the tuple (tup[0]) using another for loop.
- For each character, append it to the string.
- Once we have looped over all characters in the tuple, we append the string to our result list res.
- Finally, we print the result list.
Python3
test_list = [(['g', 'f', 'g'], 1), (['i', 's'], 2), (['b', 'e', 's', 't'], 3)]
res = []
for tup in test_list:
string = ""
for char in tup[0]:
string += char
res.append(string)
print("The joined character list tuple element to string is : " + str(res))
OutputThe joined character list tuple element to string is : ['gfg', 'is', 'best']
Time complexity: O(n^2) where n is the length of the input list test_list.
Auxiliary space: O(n), as we create a new list res to store our results, which can be of size n at most.
Explore
Python Fundamentals
Python Data Structures
Advanced Python
Data Science with Python
Web Development with Python
Python Practice