47

Is there any way to group digits in a Python code to increase code legibility? I've tried ' and _ which are digit separators of some other languages, but no avail.

A weird operator which concatenates its left hand side with its right hand side could also work out.

Utkan Gezer
  • 3,009
  • 2
  • 16
  • 29

4 Answers4

55

Update a few years later: Python 3.6 now supports PEP515, and so you can use _ for float and integer literal readability improvement.

Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 1_1000
11000
>>>

For historical reference, you can look at the lexical analysis for strict definitions python2.7, python3.5 ...

For python3.6.0a2 and earlier, you should get an error message similar to:

Python 3.6.0a2 (v3.6.0a2:378893423552, Jun 13 2016, 14:44:21) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 1_000
  File "<stdin>", line 1
    1_000
        ^
SyntaxError: invalid syntax
>>> amount = 10_000_000.0
  File "<stdin>", line 1
    amount = 10_000_000.0
                      ^
SyntaxError: invalid syntax
Foon
  • 6,148
  • 11
  • 40
  • 42
mgilson
  • 300,191
  • 65
  • 633
  • 696
5

Currently there is no thousands separator in Python, but you can use locale module to convert string with such separators to an int:

import locale
locale.setlocale(locale.LC_ALL, '')
locale.atoi("1,000,000")
scope
  • 1,967
  • 14
  • 15
3

There is no such function in Python but it was proposed to integrate it in the future.

You can see the proposal in the PEP515.

Hamlett
  • 403
  • 6
  • 22
2

The closest thing I've seen in python is 12 * 1000 * 1000, which is not ideal, but can be useful if 12000000 is needed. Be advised though, while in C, those are equivalent, because at compile time it converts both to the same thing, python may not share this optimization.

TemporalWolf
  • 7,727
  • 1
  • 30
  • 50
  • 1
    If they are literals, python will fold the constants. It won't do any folding of symbols though. – mgilson Jul 02 '16 at 00:08
  • Thanks. I thought it would, but I didn't want to spread bad info. – TemporalWolf Jul 02 '16 at 00:14
  • 2
    For 12 million, I'd use and recommend `12e6`. – Utkan Gezer Jul 02 '16 at 00:16
  • 5
    @ThoAppelsin -- Well, that depends on whether you want your value to be a `float` or an `int`... – mgilson Jul 02 '16 at 00:17
  • 4
    @TemporalWolf -- You can always check these things by disassembling the source: `dis.dis(lambda : 100 * 200 * 300)` – mgilson Jul 02 '16 at 00:18
  • 3
    @mgilson: As it happens, this is one of those things where order matters a lot. If you use `x * 100 * 1000 * 1000`, then it won't fold (because `x * 100` might not return an `int` if `x` isn't an `int`). But `100 * 1000 * 1000 * x` folds, because the left to right evaluation is working with known constants. – ShadowRanger Jul 02 '16 at 00:34