Split a string in equal parts (grouper in Python)

Grouper recipe is an extended toolset made using an existing itertool as building blocks. It collects data into fixed-length chunks or blocks. Existing Itertools Used: izip_longest(*iterables[, fillvalue]) : Make an iterator that aggregates elements from each of the iterables. If the iterables are of uneven length, missing values are filled-in with fillvalue. Iteration continues until the longest iterable is exhausted. Performance:

• The extended tools offer the same high performance as the underlying toolset.
• The superior memory performance is kept by processing elements one at a time rather than bringing the whole iterable into memory all at once.
• Code volume is kept small by linking the tools together in a functional style which helps eliminate temporary variables.
• High speed is retained by preferring “vectorized” building blocks over the use of for-loops and generators which incur interpreter overhead.

Examples:

Input : str = ABCDEFG, l = 3
Output : ABC DEF Gxx
Explanation: 
Grouping characters of string in set of 3: ABC DEF Gxx.
'x' is added to the set which doesn't have 3 elements in it. 

Input : str = GEEKSFORGEEKS, l = 5
Output : GEEKS FORGE EKSxx

  Below is the Python3 code : 

Python3

# Python3 code for the grouper recipe

# import the existing itertool izip_longest
from itertools import izip_longest

# function for the grouper recipe
def grouper(iterable, n, fillvalue ='x'):

    # create 'n'-blocks for collection
    args = [iter(iterable)] * n

    # collect data into fixed length blocks of
    # length 'n' using izip_longest and store
    # result as a list
    ans = list(izip_longest(fillvalue = fillvalue, *args))

    # (optional) loop to convert ans to string
    t = len(ans)
    for i in range(t):
        ans[i] = "".join(ans[i])

    # return ans as string
    return " ".join(ans)


# Driver code
s = "ABCDEFG"
k = 3

result = grouper(s, k)
print(result)

Output:

ABC DEF Gxx

The time complexity and auxiliary space of the above code are:

Time complexity: O(n), where n is the length of the input iterable.