Python integers

Python represents integer values in a object-oriented way that allows Python to support what might be called infinite integers - that is, a practical infinity.

This can be seen in the following code example, using "**" to represent exponentiation. Here is the Python code [#1]

i1 = 0
x1 = 1
n1 = 40
while i1 != n1:
	print("2**{0:d} is {1:,}".format(i1,x1))
	x1 *= 2
	i1 += 1

Here is the output of the Python code.

2**0 is 1
2**1 is 2
2**2 is 4
2**3 is 8
2**4 is 16
2**5 is 32
2**6 is 64
2**7 is 128
2**8 is 256
2**9 is 512
2**10 is 1,024
2**11 is 2,048
2**12 is 4,096
2**13 is 8,192
2**14 is 16,384
2**15 is 32,768
2**16 is 65,536
2**17 is 131,072
2**18 is 262,144
2**19 is 524,288
2**20 is 1,048,576
2**21 is 2,097,152
2**22 is 4,194,304
2**23 is 8,388,608
2**24 is 16,777,216
2**25 is 33,554,432
2**26 is 67,108,864
2**27 is 134,217,728
2**28 is 268,435,456
2**29 is 536,870,912
2**30 is 1,073,741,824
2**31 is 2,147,483,648
2**32 is 4,294,967,296
2**33 is 8,589,934,592
2**34 is 17,179,869,184
2**35 is 34,359,738,368
2**36 is 68,719,476,736
2**37 is 137,438,953,472
2**38 is 274,877,906,944
2**39 is 549,755,813,888

There is a computational (time and space) overhead to using this type of arithmetic.

Such an overhead can be important for certain computations, as might be needed in numerical methods, data science, etc.

Here is a similar example in c. Note that after 32 bits, there is and overflow, no error, and the result after being negative, then, on the next multiply by 2, becomes 0 and then remains at zero. Here is the C code [#1]

#include <stdio.h>
int main() {
	int i1 = 0;
	int x1 = 1;
	int n1 = 40;
	while (i1 != n1) {
		printf("2**%d is %d\n",i1,x1);
		x1 *= 2;
		i1++;
		}
	return 0;
	}

Here is the output of the C code.

2**0 is 1
2**1 is 2
2**2 is 4
2**3 is 8
2**4 is 16
2**5 is 32
2**6 is 64
2**7 is 128
2**8 is 256
2**9 is 512
2**10 is 1024
2**11 is 2048
2**12 is 4096
2**13 is 8192
2**14 is 16384
2**15 is 32768
2**16 is 65536
2**17 is 131072
2**18 is 262144
2**19 is 524288
2**20 is 1048576
2**21 is 2097152
2**22 is 4194304
2**23 is 8388608
2**24 is 16777216
2**25 is 33554432
2**26 is 67108864
2**27 is 134217728
2**28 is 268435456
2**29 is 536870912
2**30 is 1073741824
2**31 is -2147483648
2**32 is 0
2**33 is 0
2**34 is 0
2**35 is 0
2**36 is 0
2**37 is 0
2**38 is 0
2**39 is 0

Here is a similar example in java. Note that after 32 bits, there is and overflow, no error, and the result after being negative, then, on the next multiply by 2, becomes 0 and then remains at zero. Here is the Java code [#1]

public class py21_01 {
	public py21_01() {
		int i1 = 0;
		int x1 = 1;
		int n1 = 40;
		while (i1 != n1) {
			System.out.print(String.format("2**%d is %d\n",i1,x1));
			x1 *= 2;
			i1++;
			}
		}
	public static void main(String [] args) {
		new py21_01();
		}
	}

Here is the output of the Java code.

2**0 is 1
2**1 is 2
2**2 is 4
2**3 is 8
2**4 is 16
2**5 is 32
2**6 is 64
2**7 is 128
2**8 is 256
2**9 is 512
2**10 is 1024
2**11 is 2048
2**12 is 4096
2**13 is 8192
2**14 is 16384
2**15 is 32768
2**16 is 65536
2**17 is 131072
2**18 is 262144
2**19 is 524288
2**20 is 1048576
2**21 is 2097152
2**22 is 4194304
2**23 is 8388608
2**24 is 16777216
2**25 is 33554432
2**26 is 67108864
2**27 is 134217728
2**28 is 268435456
2**29 is 536870912
2**30 is 1073741824
2**31 is -2147483648
2**32 is 0
2**33 is 0
2**34 is 0
2**35 is 0
2**36 is 0
2**37 is 0
2**38 is 0
2**39 is 0