Python | Remove all strings from a list of tuples

Given a list of tuples, containing both integer and strings, the task is to remove all strings from list of tuples. 

Examples: 

Input : [(1, 'Paras'), (2, 'Jain'), (3, 'GFG'), (4, 'Cyware')]
Output :   [(1), (2), (3), (4)]

Input : [('string', 'Geeks'), (2, 225), (3, '111')]
Output : [(), (2, 225), (3,)]

Method #1: Using filter() method 

Python3

# Python code to remove all strings from a list of tuples

# Check function to check isinstance


def check(x):
    return not isinstance(x, str)


# creating list of tuples
listOfTuples = [('string', 'Paras'), (2, 'Jain'), (3, 'GFG'),
                (4, 'Cyware'), (5, 'Noida')]

# using filter
output = ([tuple(filter(check, x)) for x in listOfTuples])

# printing output
print(output)

Output:

[(), (2,), (3,), (4,), (5,)]

Time complexity: O(n), where n is the number of tuples in the list. 
Auxiliary space: O(n), where n is the number of tuples in the list. 

Method #2:

Python3

# Python code to remove all strings from a list of tuples

# Creating list of tuples
listOfTuples = [('string', 'Geeks'), (2, 225), (3, '111'),
                (4, 'Cyware'), (5, 'Noida')]


output = [tuple(j for j in i if not isinstance(j, str))
          for i in listOfTuples]

# printing output
print(output)

Output:

[(), (2, 225), (3,), (4,), (5,)]

Time complexity: O(n*m), where n is the number of tuples in the list and m is the maximum number of elements in a tuple.
Auxiliary space: O(n*m), as the output list stores all the tuples with non-string elements.

Method #3: Using type() method

STEPS:

1. Create a list of tuples, listOfTuples, containing a mix of string and non-string elements.
2. Create an empty list, x, to store the tuples containing only non-string elements.
3. Iterate over each tuple in listOfTuples using a for loop.
4. For each tuple, create an empty list, p, to store the non-string elements.
5. Iterate over each element in the current tuple using a nested for loop.
6. If the current element is not a string (determined using the type() function), append it to the p list.
7. Convert the p list into a tuple using the tuple() function.
8. Append the tuple containing only non-string elements to the x list.
9. After all tuples have been processed, print the x list.

Python3

# Python code to remove all strings from a list of tuples

# creating list of tuples
listOfTuples = [('string', 'Paras'), (2, 'Jain'),
                (3, 'GFG'), (4, 'Cyware'), (5, 'Noida')]
x = []
for i in listOfTuples:
    p = []
    for j in i:
        if(not (type(j) is str)):
            p.append(j)
    p = tuple(p)
    x.append(p)

# printing output
print(x)

Output

[(), (2,), (3,), (4,), (5,)]

Method #4: Using inspect

To check if a variable is a string in Python, you can use the inspect module and the isclass function. Here is an example of how you can use this approach:

Python3

import inspect

def is_string(value):
    return inspect.isclass(type(value)) and issubclass(type(value), str)

# Test the function
print(is_string("hello"))  # Output: True
print(is_string(123))      # Output: False
print(is_string(True))     # Output: False
#This code is contributed by Edula Vinay Kumar Reddy

Output

True
False
False

This approach will return True if the variable is a string, and False otherwise. It works by checking if the type of the variable is a class, and if that class is a subclass of the str class.

This approach can be used to remove all strings from a list of tuples by iterating through the list and filtering out the tuples that contain strings. Here is an example of how you could do this:

Python3

import inspect

def remove_strings_from_tuples(tuples):
    def is_string(value):
        return inspect.isclass(type(value)) and issubclass(type(value), str)

    return [tuple(value for value in t if not is_string(value)) for t in tuples]

tuples = [('string', 'Geeks'), (2, 225), (3, '111'), (4, 'Cyware'), (5, 'Noida')]
print(remove_strings_from_tuples(tuples))  # Output: [(), (2, 225), (3,), (4,), (5,)]

#This code is contributed by Edula Vinay Kumar Reddy

Output

[(), (2, 225), (3,), (4,), (5,)]

Time complexity: O(n * m) where n is the number of tuples and m is the number of elements in each tuple. This is because the code needs to iterate through all tuples and all elements in each tuple to check if it is a string or not.
Auxiliary space: O(n * m) as well because the code creates a new list of tuples with the same number of tuples and elements as the original list of tuples.

Method #5: Using Regular expression method.

Algorithm:

• Iterate over each tuple in the list of tuples.
• For each tuple, iterate over each item in the tuple.
• If the item is not a string, append it to a new list.
• If the item is a string, use a regular expression to remove all characters in the string that are alphabetic characters.
• Append the modified or unmodified item to the new list.
• Convert the new list to a tuple and append it to the final list.
• Return the final list of tuples.

Python3

import re
listOfTuples = [('string', 'Paras'), (2, 'Jain'), (3, 'GFG'), (4, 'Cyware'), (5, 'Noida')]

def remove_strings(tup):
    pattern = r'[a-zA-Z]+'
    result = []
    for item in tup:
        if not isinstance(item, str):
            result.append(item)
        else:
            result.append(re.sub(pattern,'', item))
            result.remove('')
    return tuple(result)

newList = [remove_strings(tup) for tup in listOfTuples]
print(newList)
#This code is contributed by tvsk

Output

[(), (2,), (3,), (4,), (5,)]

Time complexity:
The time complexity of this algorithm is O(n*m) where n is the number of tuples and m is the maximum length of a string in a tuple. This is because we need to iterate over each tuple and then iterate over each item in the tuple to check whether it is a string and perform the regular expression operation on it.

Auxiliary Space:
The auxiliary space of this algorithm is O(n*m) where n is the number of tuples and m is the maximum length of a string in a tuple. This is because we need to create a new list to store the modified or unmodified items for each tuple, and the length of each list is at most the length of the original tuple.

Method 5: Using a loop and isinstance() function:

Step-by-step approach:

• Define an empty list to store the tuples without strings
• Loop through each tuple in the list of tuples
• Define an empty tuple to store the non-string values from the current tuple
• Loop through each element in the current tuple
• Check if the current element is a string using isinstance() function
• If the element is not a string, append it to the empty tuple defined in step 3
• After looping through all the elements in the current tuple, append the non-string tuple to the empty list defined in step 1
• After looping through all the tuples in the list of tuples, print the final list of tuples without strings.

Below is the implementation of the above approach:

Python3

# Python code to remove all strings from a list of tuples

# Creating list of tuples
listOfTuples = [('string', 'Geeks'), (2, 225), (3, '111'),
                (4, 'Cyware'), (5, 'Noida')]

# Step 1
output = []

# Step 2
for tup in listOfTuples:

    # Step 3
    new_tup = ()

    # Step 4
    for ele in tup:

        # Step 5
        if not isinstance(ele, str):

            # Step 6
            new_tup += (ele,)

    # Step 7
    output.append(new_tup)

# Step 8
print(output)

Output

[(), (2, 225), (3,), (4,), (5,)]

Time complexity: O(n^2), where n is the total number of elements in the list of tuples. 
Auxiliary space: O(n), where n is the total number of elements in the list.

Method 6: Using heapq:

1. Define an inner function is_string that takes a value as input and returns a boolean indicating whether the value is a string or not.
2. Use a list comprehension to iterate through each tuple in tuples. For each tuple, create a new tuple by iterating through each value in the original tuple and selecting only the non-string values. The new tuple is added to a list of tuples that will be returned.
3. Return the list of tuples.

Python3

import heapq

def remove_strings_from_tuples(tuples):
    def is_string(value):
        return isinstance(value, str)

    return [tuple(value for value in t if not is_string(value)) for t in tuples]

tuples = [('string', 'Geeks'), (2, 225), (3, '111'), (4, 'Cyware'), (5, 'Noida')]
print(remove_strings_from_tuples(tuples)) # Output: [(), (2, 225), (3,), (4,), (5,)]
#This code is contributed by Rayudu.

Output

[(), (2, 225), (3,), (4,), (5,)]

Time complexity:

The filter function iterates over the elements of each tuple in tuples, which takes O(nm) time, where n is the number of tuples in tuples and m is the maximum length of a tuple.
For each tuple, the filter function checks whether each element is a string, which takes O(m) time in the worst case.
The tuple function creates a new tuple from the filtered elements, which takes O(m) time in the worst case.
Therefore, the total time complexity of the function is O(nm^2).

Auxiliary Space:

The filter function returns an iterator that yields elements from the original tuple, so it does not create a new list or tuple. Therefore, the space complexity of the function is O(nm).
The tuple function creates a new tuple from the filtered elements, so it adds O(m) space complexity for each tuple in tuples.
Therefore, the total space complexity of the function is O(nm).