Python: Formatting Large Integer

Hello again. Hehe.

This is an equivalency method in Python of earlier JavaScript post about Formatting Large Integer. It has demos of the method (in JavaScript).

So before we start, the number format in any application, usually, needs to be readable (for interface, such as the dilly we look at) and process-able -- the original format for calculation and then it will be displayed on the dilly we look at.

This is a method to make a large integer readable, of some sort. In another words, this is a Python snippet to insert separators between digits.

There are countries which use comma as large digit separator and point as decimal mark, and there are countries that use the opposite of that.

The first concept, for example:

1,000,400 (large integer) -- it's one million and four hundred
23.58 (decimal) -- twenty three point fifty eight
1,000,000.253 (seriously) -- one million point two hundred and fifty three

And the second one:

1.000.400 (large integer) -- one million and four hundred
23,58 (decimal) -- twenty three comma fifty eight
1.000.000,253 (yeah that) -- one million and stuff

Why they differ? It's history department, long story long, it had something to do with the ancient Roman.

Anyway, the snippet below only focuses on the first one of all, the large integer.
To format an integer larger than 999 to be like either of those -- positive and negative (smaller than -999).

Here it goes:

"""
Function name:
    num_formatter
Function invocation:
    num_formatter(a, b)
The inputs:
    1. Input a must be an integer or string with just integer in it.
    2. Input b can be 1 comma or 1 point (string).
Example invocation:
    > print num_formatter(3500, ",")
Example output:
    > 3,500 (string)
"""
def num_formatter(a, b):
    import math # Mathematical module
    import re # RegExp module
    
    # 1. Filter for 1st input -> a
    try:
        try:
            a = int(a)
        except ValueError: # a is not integer
            return a
    except TypeError: # a is not string/number
        return a
        
    # 2. Filter 2nd input -> b
    if re.search(r"^\.$|^,$", b) == None: # b isn't 1 comma or 1 point (string)
        return a
    else:
        # 3. Actual method for valid inputs -> a and b
        minus = ""
        if a < 0:
            minus = "-"
            a = abs(a) # a -> positive integer
        i = 1
        f = list(reversed(list(str(a)))) # Convert to list and reverse it
        while i <= math.floor(len(f) / 4):
            ix = 4 * i - 1 # The index of where the separator will be inserted
            f.insert(ix, b) # This is the separator inserting method
            i += 1
        result = minus + "".join(list(reversed(list(f)))) # Final output
        return result

This function is equipped with two filters at the beginning. If either one (a or b) is invalid, it won't do any "formatting", just return the original value.

The concept is the exact same as the earlier JavaScript post, and it's translated to Python.

These are the outputs on my Python interpreter:

The output of this is a string type.

This "helper" function can be expanded to accommodate floating number and such, plus adding the head and tail. Like, $1,000.00 or $1,000.- and so on. Depends on your data structure.

And then, to revert it back to number, we can strip either the comma or point or any other string (using replace), and convert it to integer (or float/long).

That's the glimpse of it. See you again.

Monkey Raptor

Monkey Raptor

Wednesday, March 16, 2016

Python: Formatting Large Integer

No comments

Post a Comment