# Python | Merge Tuple String List values to String

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))`

Output

`The 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)))`

Output

`The 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

1. Import the reduce() function from the functools module.
2. Initialize the input list with tuples containing string lists and integer values.
3. Define a lambda function to concatenate the string lists in each tuple.
4. 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))`

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), 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) 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))`

Output

`The 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.

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!

Previous
Next