Hello, dear Pythonics. :) In today's article we shall continue with our topic category 10 Useful Python Functions. If you haven't checked out the previous articles under the same category, here it is 10 Useful Python Functions: Part 2.

6. Enumerate

Suppose you would like to loop through a list or a tuple of values and print each value, but also each value's index, both people either coming from other programming languages and new ones to programming would do something like this:

Code snippet 1.1

my_list = ["I", "learned", "new", "coding", "tricks", "today"]
index = 0

for i in my_list:
    index += 1
    print(index, i)

"""
prints

3 I
4 learned
5 new
6 coding
7 tricks
8 today

"""

It works as expected, but is it the best approach though? You have to first create a variable and assign a value of zero to it and update that value on each loop. Sounds exhausting if you're an interpreter, and it is not 'Pythonic'. Python offers a builtin method that does quite the same but elegantly: enumerate()

Code snippet 1.2

my_list = ["I", "learned", "new", "coding", "tricks", "today"]

for i, v in enumerate(my_list):
  print(i, v)

"""
prints

0 I
1 learned
2 new
3 coding
4 tricks
5 today

"""

Quite clean, right? The i is the index and the v is the current value. These are just naming convestions of course, you can named them whatever as long as they're valid Python variable names (avoid builtin and Python reserved words). What matters is that the first variable is for indices and the second for your values. We use the method enumerate() on our next function.

7. Context in a For-loop

Code snippet 1.3

# My list of values

my_list = ["I", "learned", "new", "coding", "tricks", "today"]

def get_context(lst):
    previous_token = None
    next_token = None
    for index, token in enumerate(my_list):
        if index > 0:
            previous_token = my_list[index - 1]
        if index < (len(my_list) - 1):
            next_token = my_list[index + 1]
        print(previous_token, token, next_token)

get_context(my_list)

"""
prints

None I learned
I learned new
learned new coding
new coding tricks
coding tricks today
tricks today today

"""

The method above is simple: it takes a list (or tuple) of values and prints the current token, the previous token and the next token. We use the term token to refer to a value. We first define the two variables previous_token and next_token, and then we make use of the builtin method enumerate() to provide us with the current token's index, which we use later to get the previous token and the next token. For example imagine the current token is 'coding' which is at index 3 from the left (index=3), to get the previous token, we use index - 1 to refer to the previous token 'new' and index + 1 to refer to the next token 'tricks', but we also have a couple of if conditional statements that check whether there is a "previous" and a "next" beforehand. If we didn't have these checks, we would run into errors such as IndexError: list index out of range. So, for example there is always a next token as long as the index is smaller than the length_of_the_list - 1:

e.g. if 2 < (5 - 1) Which is true.

Here is the same method above written in a more concise manner:

Code snippet 1.4

def get_context(my_list):
    previous_token = next_token = None
    for index, token in enumerate(my_list):
        previous_token = my_list[index - 1] if index > 0 else None
        next_token = my_list[index + 1] if index < (len(my_list) - 1) else None
        print(previous_token, token, next_token)

"""
prints the same as above
"""

If you've just started learning Python and the structure of the code above seems a little different than what you might have been learning, it's okay. I shall make a separate article covering all what you will need to know about such structure and how to make use of it.

8. Is-One-Token

Code snippet 1.5

import re

def is_one_token(data):
    return len(re.split("\s+", data)) == 1

The above method takes in a datatype object of type string or bytes-like object, if you pass anything else such as a list, a tuple, a dict, etc, you'll get a TypeError error. What it does basically is check whether the variable data is one token: It uses the the regular expression module re to check for any space-like separators (spaces, tabs, and newlines), if none found it will return True, which means that the tokens is a single one, if it returns False, it means otherwise. Example:

Code snippet 1.6

data = "some string here"
is_one_token(data)

"""
returns False
"""

data = "Python"
is_one_token(data)

"""
returns True

"""

data = " "
is_one_token(data)

"""
returns False
"""

data = None
is_one_token(data)

"""
Raises a TypeError
"""

data = ""
is_one_token(data)

"""
returns True
"""

You see that even if data was empty, it returns True, since there are no space-like separators. And if we pass in a data type that is not a string or bytes-like, it will raise an error. So you might need to perform other checks as the following:

Code snippet 1.7

import re

def is_one_token(data):
    if isinstance(data, str):
        if data != "":
            return len(re.split("\s+", data)) == 1
        else:
            return "Empty string"
    return "Invalid data {}".format(type(data))

The newly modified method handles all types of checks you may come across. It first checks if the data provided is of type string with the builtin isinstance(), if negative, it returns an error, if affirmative, it checks if data is not an empty string, if negative, it returns False, if otherwise it continues to validate if data is one token or more. To test most possible inputs, we run the following test:

Code snippet 1.8

data = ["Python and the boys", "Python", " ", "", {"k":7}, None, [7,1,4]]

for d in data:
    print(is_one_token(d))

"""
returns

False
True
False
Empty string
Invalid data <class 'dict'>
Invalid data <class 'NoneType'>
Invalid data <class 'list'>

"""

9. Deep-Flatten

Code snippet 1.9

def deep_flatten(data):
    flat_list = []
    [flat_list.extend(deep_flatten(d)) for d in data] if isinstance(data, list) else flat_list.append(data)
    return flat_list

You may not always know what kind of data you're getting, especially from users. But your processing must be consistent and clean. Imagine for example a situation where you have a method or a class object that takes in only data of type list, you will have to first filter out any non-list data type, then you'll have only data of type list. For example the final data to process after filtering is as the following:

data = [1,12,55,454,48,9,6, [5,54,8,6,7,[7,54,53,6,0]],[87,8,1,45]]

And you may want to loop through them and process each string, but you have other lists within your list. The deep_flatten method checks whether the current value is of type list, if affirmative, is loops through that list and extends its values to a per-defined empty list named flat_list, if negative, it appends the value to the same list. So the above data would be rendered as:

"""
list retuned: of all strings of the outer list (data) and its inner lists
[1, 12, 55, 454, 48, 9, 6, 5, 54, 8, 6, 7, 7, 54, 53, 6, 0, 87, 8, 1, 45]
"""

Now your data is one list of tokens that you could loop through and do whatever you is needed.

10. Chunk

Code snippet 2.0

def chunk(data, size):
    return [data[i:i+size] for i in range(0,len(data), size)]

You have a list of n size that you wish to chunk into smaller lists of size i. The above method takes in two arguments, a data of type list, tuple or string, and a size argument of type int. In this case we deal with lists, but the same thing is true for the other two data types mentioned. Size is the length of the chunked list to be produced. For example a list of length 11 with an argument size of 2, will produce the following:

Code snippet 2.1

data = [1,12,55,454,48,9,6,454,48,9,0]
size = 2

chunk(data, size)

"""
returns 
[[1, 12], [55, 454], [48, 9], [6, 454], [48, 9], [0]]
"""

Since the length of the list is an odd number and the size is an even one, it produced 5 lists of size 2 and one of size 1.

Well, guys, I think this is it for this category. I know some of you might feel as if I am over explaining things, and I sometimes feel I do, but I want each piece of code to make, not essentially perfect, but at least good sense and be comprehensible by most, even with little programming background. I hope you find these articles useful and thank you for being on board.

10 Useful Python Functions: Part 3 and last

Majdi Mahfoud