Hello, there. In today's article, I am going to share with you some simple, yet very useful functions. If you are new to Python, please make sure you check out the introductory articles beforehand as some functions might seem a little of nonsense and fuzzy. Alright then, here we go!

1. All Unique

Code snippet 1.0

def all_unique(lst):
    return len(lst) == len(set(lst))

The function above is so simple, yet so powerful, what it does basically is check if a given list of values has all unique values. So what does that really mean and how does is work? Imagine you have a list of different values, and you want to check if they are all unique before any further processing. For example:

Code snippet 1.1

#v1

my_list = ['A', 'B', 'C', 'D', 'A', 'A', 'C']
# Our list of values

def some_expensive_function(value):# do some expensive calculations here
    return value*2

for v in my_list:
    print(some_expensive_function(v))

print("All values have been processed")

The code above is very simple, we have a list of values, a function that processes those values, and a for-loop that iterates throughout the whole list.

Output of Code snippet 1.1

The code is working and everyone is happy. Right? Well, kind of. Imagine you have a real long, complex list of values, say of hundred of thousands of values, or millions, and you have real expensive calculations instead of printing the given values; as long as redundancy of values is of no importance to you, you surely want that list of values to be unique to avoid unnecessary usages of processing power and resources.

Code snippet 1.2

#v2

my_list = ['A', 'B', 'C', 'D', 'A', 'A', 'C']
# Our list of values

def all_unique(lst):
    return len(lst) == len(set(lst))

def make_unique(lst):
    return set(lst)

def some_expensive_function(my_list):# do some expensive calculations here
    for v in my_list:
        print(v*2)

def preprocess(my_list):
    if all_unique(my_list):
        return some_expensive_function(my_list)
    return some_expensive_function(make_unique(my_list))

We have modified our code and added a couple of other methods: make_unique and preprocess(). What the preprocess() method does is basically check if a list of given values is unique or not, if affirmative, it calls some_expensive_function() and passes the given list, if otherwise, it first calls the make_unique() method, the latter one uses the built-in method set() which returns only unique values, thus it sets our given list to only unique values, afterwards our now-unique list is passed to some_expensive_function() so it can be further processed.

Here is the same function written differently:

Code snippet 1.3

# returns True if all values are unique
def all_unique(lst):
    return len(lst) == len(set(lst))

# returns True if at least one value id duplicated
def has_duplicates(lst):
    return len(lst) != len(set(lst))

2. Delete From Index

Code snippet 1.4

def delete_from_index(token, index):
    return token[:index] + token[index+1:]

Sometimes you would want to modify or delete some specific character(s) of a given string for one purpose or another, the built-in method replace() could make do, but most of times it won't be so helpful.

Code snippet 1.5

#v1

string = 'SomeSStringX'
string = string.replace(string[-1], '')
# deletes the last character at index -1.
print(string)
#prints 'SomeSString'

All good so far, right? Well, again, kind of. What if wanted to delete the repeated 'S' at 'SomeSString'? That's at the index -7 from the right (first encountered 'S'), or index 4 from the left. So let's go ahead and delete it.

Code snippet 1.6

#v2

string = 'SomeSStringX'
string = string.replace(string[4], '')
# deletes the character at index 4.
print(string)
#prints 'ometring'

Oh, not what you might have expected, is it? Maybe. The approach above not only deletes the target 'S' at index 4, but also all the other 'S' in the string. So why is that? Python strings and some other data types are immutable, meaning you cannot perform such operations on them using such methods. We could convert our string into a list then delete the value at the index like the following:

Code snippet 1.7

#v3

string = 'SomeSStringX'
my_string_list = list(string)
"""
returns list ['S', 'o', 'm', 'e', 'S', 'S', 't', 'r', 'i', 'n', 'g', 'X']
"""
del my_string_list[4]
string = ''.join(string)
print(string)
#prints 'SomeStringX'

The current approach is working properly, but you might need to perform the same operation on different strings at different times and places on your code. Besides, converting a string to a list and deleting the desired value then converting it back into a string is not the best approach, so the best one so far is to wrap the code in a method which uses string slicing, thus our delete_from_index()

def delete_from_index(token, index):
    return token[:index] + token[index+1:]

Now, what you would do is just:

Code snippet 1.8

#v4

string = 'SomeSStringX'
string = delete_from_index(string, 4)
print(string)
#prints 'SomeStringX'

The advantage of this method is that you can pass any string and any index you wish to delete and it will get the job done nice and clean.

Hope you find this useful. Other functions on the coming parts of this category Python Useful Functions

10 Useful Python Functions

Majdi Mahfoud