Python | Remove all strings from a list of tuples
Last Updated : 12 Apr, 2023
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
def check(x):
return not isinstance(x, str)
listOfTuples = [('string', 'Paras'), (2, 'Jain'), (3, 'GFG'),
(4, 'Cyware'), (5, 'Noida')]
output = ([tuple(filter(check, x)) for x in listOfTuples])
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
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]
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:
- Create a list of tuples, listOfTuples, containing a mix of string and non-string elements.
- Create an empty list, x, to store the tuples containing only non-string elements.
- Iterate over each tuple in listOfTuples using a for loop.
- For each tuple, create an empty list, p, to store the non-string elements.
- Iterate over each element in the current tuple using a nested for loop.
- If the current element is not a string (determined using the type() function), append it to the p list.
- Convert the p list into a tuple using the tuple() function.
- Append the tuple containing only non-string elements to the x list.
- After all tuples have been processed, print the x list.
Python3
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)
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)
print(is_string("hello"))
print(is_string(123))
print(is_string(True))
|
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,)]
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)
|
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
listOfTuples = [('string', 'Geeks'), (2, 225), (3, '111'),
(4, 'Cyware'), (5, 'Noida')]
output = []
for tup in listOfTuples:
new_tup = ()
for ele in tup:
if not isinstance(ele, str):
new_tup += (ele,)
output.append(new_tup)
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:
- 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.
- 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.
- 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,)]
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).
Similar Reads
Python | Remove all digits from a list of strings
The problem is about removing all numeric digits from each string in a given list of strings. We are provided with a list where each element is a string and the task is to remove any digits (0-9) from each string, leaving only the non-digit characters. In this article, we'll explore multiple methods
4 min read
Python | Remove duplicate tuples from list of tuples
Given a list of tuples, Write a Python program to remove all the duplicated tuples from the given list. Examples: Input : [(1, 2), (5, 7), (3, 6), (1, 2)] Output : [(1, 2), (5, 7), (3, 6)] Input : [('a', 'z'), ('a', 'x'), ('z', 'x'), ('a', 'x'), ('z', 'x')] Output : [('a', 'z'), ('a', 'x'), ('z', 'x
5 min read
Python | Remove prefix strings from list
Sometimes, while working with data, we can have a problem in which we need to filter the strings list in such a way that strings starting with a specific prefix are removed. Let's discuss certain ways in which this task can be performed. Method #1 : Using loop + remove() + startswith() The combinati
5 min read
Python | Removing strings from tuple
Sometimes we can come across the issue in which we receive data in form of tuple and we just want the numbers from it and wish to erase all the strings from them. This has a useful utility in Web-Development and Machine Learning as well. Let's discuss certain ways in which this particular task can b
4 min read
Python - Remove substring list from String
In Python Strings we encounter problems where we need to remove a substring from a string. However, in some cases, we need to handle a list of substrings to be removed, ensuring the string is adjusted accordingly. Using String Replace in a LoopThis method iterates through the list of substrings and
3 min read
Python - Remove suffix from string list
To remove a suffix from a list of strings, we identify and exclude elements that end with the specified suffix. This involves checking each string in the list and ensuring it doesn't have the unwanted suffix at the end, resulting in a list with only the desired elements. Using list comprehensionUsin
3 min read
Python - Remove String from String List
This particular article is indeed a very useful one for Machine Learning enthusiast as it solves a good problem for them. In Machine Learning we generally encounter this issue of getting a particular string in huge amount of data and handling that sometimes becomes a tedious task. Lets discuss certa
4 min read
Remove Duplicate Strings from a List in Python
Removing duplicates helps in reducing redundancy and improving data consistency. In this article, we will explore various ways to do this. set() method converts the list into a set, which automatically removes duplicates because sets do not allow duplicate values. [GFGTABS] Python a = ["Learn
3 min read
Create a tuple from string and list - Python
The task of creating a tuple from a string and a list in Python involves combining elements from both data types into a single tuple. The list elements are added as individual items and the string is treated as a single element within the tuple. For example, given a = ["gfg", "is"] and b = "best", t
3 min read
Python | Remove Kth character from strings list
Sometimes, while working with data, we can have a problem in which we need to remove a particular column, i.e the Kth character from string list. String are immutable, hence removal just means re creating a string without the Kth character. Let's discuss certain ways in which this task can be perfor
7 min read