What's actually happening when I convert an int to a string?

Question

I understand it's easy to convert an int to a string by using the built-in method str(). However, what's actually happening? I understand it may point to the __str__ method of the int object but how does it then compute the “informal” string representation? Tried looking at the source and didn't find a lead; any help appreciated.

Answer 1

Python repeatedly divides the int by 10 and uses % 10 to get the decimal digits one by one.

Just to make sure we're looking at the right code, here's the function Python 2.7 uses to convert ints to strings:

static PyObject *
int_to_decimal_string(PyIntObject *v) {
    char buf[sizeof(long)*CHAR_BIT/3+6], *p, *bufend;
    long n = v->ob_ival;
    unsigned long absn;
    p = bufend = buf + sizeof(buf);
    absn = n < 0 ? 0UL - n : n;
    do {
        *--p = '0' + (char)(absn % 10);
        absn /= 10;
    } while (absn);
    if (n < 0)
        *--p = '-';
    return PyString_FromStringAndSize(p, bufend - p);
}

This allocates enough space to store the characters of the string, then fills the digits in one by one, starting at the end. When it's done with the digits, it sticks a - sign on the front if the number is negative and constructs a Python string object from the characters. Translating that into Python, we get the following:

def int_to_decimal_string(n):
    chars = [None] * enough # enough room for any int's string representation
    abs_n = abs(n)
    i = 0
    while True:
        i += 1
        chars[-i] = str(abs_n % 10) # chr(ord('0') + abs_n % 10) is more accurate
        abs_n //= 10
        if not abs_n:
            break
    if n < 0:
        i += 1
        chars[-i] = '-'
    return ''.join(chars[-i:])

Answer 2

Internally the Int object is stored as 2's complement representation like in C (well, this is true if range value allow it, python can automagically convert it to some other representation if it does not fit any more).

Now to get the string representation you have to change that to a string (and a string merely some unmutable list of chars). The algorithm is simple mathematical computing: divide the number by 10 (integer division) and keep the remainder, add that to character code '0'. You get the unit digit. Go on with the result of the division until the result of the division is zero. It's as simple as that.

This approach works with any integer representation but of course it will be more efficient to call the ltoa C library function or equivalent C code to do that if possible than code it in python.