Representing large numbers in python: the underscore separator

Chidambaram Manivannan — Mon, 21 Sep 2026 13:19:01 +0000

Recently, I learnt a simple way of representing large numbers in python. Say, I had a large number like 8736570164

I had to manually (and erratically) point my finger at the monitor on that number - look for tens, thousands, millions, etc., draw imaginary commas and come to a conclusion, as taught in school. If we cleverly had to include the commas in the number itself, python treats them as items of a tuple, separated by those commas.

num = 8,736,570,164 # -> num = (8, 736, 570, 164)

# Print an awesome loop from 0 to 12345
for i in range(12,346):
  print(i) # -> Oops! It prints from 12 to 345

So, what is the way then? Turns out, python (since version 3.6) provides the underscore character for digit separation, making it easier for human reading.

1_234_567_890 == 1234567890 # -> True
# Both are the number 1,234,567,890

So now, we can print our loop correctly, like:

# So now, I can print it better
for i in range(12_346):
  print(i) # -> Voila! It prints from 0 to 12345

Now let us see some basic rules for this digit separator in numeric literals.

A number cannot start or end with an underscore.

num = _314 # -> Error! Well, it creates a variable identifier, not a numeric literal
num = 314_ # -> Error!

There cannot be multiple underscore separators next to each other.

12__345 # -> Error!

Underscore separators can also be used for floats. But, there cannot be an underscore separator right next to the decimal point.

num = 3_.141592 # -> Error 
num = 3._141592 # -> Also an error 

num = 3.141_592 # -> Correct!

One last point: let us learn how to output an underscore separated number, given a normal one. We just have to convert it to a formatted string. Python adds in the separators based on the 'International Number System' (thousands, million, billion, etc.,).

num = 1234567890
print(f'{num:_}') # -> 1_234_567_890

When you ask AI to write your code, it typically always writes plain numeric literals like 1234567890.
If you want the AI to write how we humans want to read easily, specify in the prompt to "Format large numbers with underscore digit separators."

Code is read far more often than it is written, so save yourself (and your teammates) the headache of counting digits. Happy coding!

I never fully understood Python for loops until I grasped the range function. Here is what I learnt

Chidambaram Manivannan — Thu, 17 Sep 2026 20:32:56 +0000

I come from a C Programming background, where for loops are very simple.

for(int i = 0; i < n; i++) {
    // Your fabulous code block
}

This was intuitively easy to understand.

The first part int i = 0 is the initialization (the starting point) for the iterator. It is also nice that this int lives and dies within the scope of this for loop (block-scoped).
The second part i < n is the condition (test expression) that is checked for every iteration, before our fabulous code block gets executed.
The third part i++ is the iteration (update) that happens at the end of every execution of our code block.

Now, if you are a pure-blooded Pythonista and you think that that loop definition is cryptic, please hear me out. With this simple setup, C can do a lot of funky loops, like:

for(int i = 1; i < n; i = i * 2) 
// Oh look, an O(log n) loop!

for(int i = 2; i < n; i = i * i)
// Holy Hulk! An even better O(log log n) loop!

You get the drift. Fundamentally, every such for loop is easy to decode and understand. All good!

But when it came to Python, I was lost.

# A typical python for loop
for i in range(10):

Uhhhh, hello? Where does it start? What is checked? Who increments what?
Turns out, it was all syntactic sugar.
[It is technically more than just sugar.]

The definition is, behind the scenes:

for i in range(0, 10, 1):
# First argument 0 is inclusive
# Second argument 10 is non-inclusive
# Third argument is the step

range(10) == range(0, 10, 1) # -> True
range(10) == range(0, 10) # -> True

Okay, but what exactly is the 'range' here?
It just forms an object of type 'range' (since Python 3.0) which is nothing but a placeholder that signals where the loop starts, ends and increments. Technically, it is an immutable sequence object that represents the numbers in the range without actually storing all of them in memory.
Creating a range object takes O(1) space and time, regardless of how large the range is.

All those book-ish definitions are fine. But how do we better visualize it? Convert it to a list!

# Python REPL

# The default iterator increment is always 1
>>> range(10) # -> range(0, 10)
>>> range(10) == range(0, 10, 1) # -> True
>>> list(range(0, 10, 1)) # -> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Single digit odd numbers
>>> list(range(1, 10, 2)) # -> [1, 3, 5, 7, 9]

# Single digit even numbers
>>> list(range(0, 10, 2)) # -> [0, 2, 4, 6, 8]

Now we get it! We can extend this concept to scale and even to decrement instead of incrementing

>>> list(range(10, 0, -1)) # -> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

And of course, Python's for..in loop directly iterates over collections like list, tuple, dict or str, visiting each item in turn (or each key, in the case of a dict).

Splendid! But where are the O(log n) for loops?
Ah, that is where the "loop-hole" of Python lies. This can be done easier with a humble while loop.

i = 1
while i <= n:
    # Your awesome code!
    i *= 2

A for loop version exists but it is way trickier and beyond the scope of this post.

There, now your for-loop-in-range understanding is rock solid :)

This post is not to diss Python, not at all. In fact, Python's for loops have more capabilities than C's but I got to grok it only when I properly learnt the range function.

I will be happy to hear from you about any more such silly quirks of Python compared to C or other languages, in the comments.

DEV Community: Chidambaram Manivannan

Representing large numbers in python: the underscore separator

I never fully understood Python for loops until I grasped the range function. Here is what I learnt