# Python Integers

Python Integers
0

#1

The theoretical domain for integers in python is negative infinity to infinity. In practice, integer values are limited by the amount of available memory.

In Python 2, there was a distinction between `int`, numbers that fit in a 32 or 64 bit C long, and `long`, numbers limited by available memory. Python 3 unified the two types into just `int`, more info in PEP 237.

`int` creation using integer literals

Integer Literals

Integer objects can be created using using integer literals. Unadorned numbers without decimals are integer literals:

``````>>> 1234567890           # Unadorned numbers are integer literals
1234567890
>>> type(1234567890)
<class 'int'>
``````

Numeric literals do not contain a sign, however creating negative integer objects is possible by prefixing with a unary `-` (minus) operator with no space before the literal:

``````>>> -1234567890
-1234567890
>>> type(-1234567890)
<class 'int'>
``````

Likewise, positive integer objects can be created by prefixing a unary `+` (plus) operator with no space before the digits. Usually `+` is ommited:

``````>>> +1234
1234
``````

Binary (base 2, prefix: `0b` or `0B`), octal (base 8, prefix: `0o` or `0O`), and hexadecimal (base 16, prefix: `0x` or `0X`) integers can also be created using integer literals:

``````>>> 0b1, 0b10, 0b11
(1, 2, 3)
>>> 0o1, 0o10, 0o11
(1, 8, 9)
>>> 0x1, 0x10, 0x11
(1, 16, 17)
``````

Note that leading 0’s for non-zero integer literals are not allowed:

``````>>> 0     # Zero by itself is okay.
0
>>> 01    # Leading zero(s) cause SyntaxError.
File "<stdin>", line 1
01
^
SyntaxError: invalid token
``````

The `int` constructor is another way to create integer objects.

``````class int(x=0)
class int(x, base=10)
``````

Creating integer objects with integer literals is preferred when possible:

``````>>> a = 1         # Prefer integer literal when possible.
>>> type(a)
<class 'int'>
>>> b = int(1)    # Works but unnecessary.
>>> type(b)
<class 'int'>
``````

However, the constructor allows for creating integer objects from other number types:

``````>>> a = 1.123
>>> type(a)
<class 'float'>
>>> print(a)
1.123
>>> b = int(1.123)
>>> type(b)
<class 'int'>
>>> print(b)
1
``````

Using the `int` constructor for floating point numbers will truncate the number towards zero:

``````>>> int(-1.23)
-1
>>> int(1.23)
1
``````

The built-in `boolean` constants are instances of the `bool` class, and are subclasses of the `int` class, making them a kind of numeric type:

``````>>> type(True)
<class 'bool'>
>>> issubclass(bool, int)
True
``````

If that doesn’t make sense to you, don’t worry. For now just remember that calling the int constructor with `boolean` objects will return integer objects:

``````>>> int(True)
1
>>> int(False)
0
``````

The `int` constructor will also make integer objects from strings:

``````>>> a = "10"
>>> type(a)
<class 'str'>
>>> b = int("10")
>>> type(b)
<class 'int'>
``````

Strings for the `int` constructor must represent an integer literal:

The second parameter of the `int` constructor is to specify a base (default: 10). Valid bases are 0 and 2-36.

If an explicit base is provided the first argument must be a string.

``````>>> int("111", 2)
7
>>> int(111, 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: int() can't convert non-string with explicit base
``````

The string used for the `int` constructor with an explicit base must be a valid integer literal for that base:

``````>>> int('11', 2)
3
>>> int('12', 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 2: '12'
``````

Both prefixed and non-prefixed strings of integer literals can be used, however, if used, the prefix must match the provided base.

``````>>> int('1101', 2)
13
>>> int('0b1101', 2)
13
>>> int('0x1101', 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 2: '0x1101'
``````

If a prefixed string and base 0 is used, the created integer object will use the base specified by the prefix. If no prefix is used, then the base is assumed 10

``````>>> int('100', 0)
100
>>> int('0b100', 0)
4
>>> int('0o100', 0)
64
``````

#2