Python. Numbers. Representation of numbers of different types. Basic numeric types. Number conversion functions

Numbers. Representation of numbers of different types. Basic numeric types. Number conversion functions


Search other websites:

1. Categories of numeric types

In Python, number types are represented by the following categories:

  • ordinary numeric types (real, integer);
  • literals (create numeric types);
  • expressions (processing of numeric types).


2. List of numeric types

The following numeric types are supported in Python:

  • integers and real numbers;
  • complex numbers;
  • fixed precision numbers;
  • rational numbers;
  • sets
  • logical values;
  • integers of unlimited precision.


3. Representation of integers (literals) in different calculus systems. Example

Integers (or integer literals) can be written in different calculus systems:

  • decimal format;
  • hexadecimal;
  • octal;
  • binary.

Example. Writing the number (literal) 30 in various formats

30 # decimal format
0x1e # hexadecimal
0X1E # hexadecimal
036 # octal, Python 2.6
0B11110 # binary
0b11110 # binary
0O36 # octal, Python 3.0
0o36 # octal, Python 3.0

If you try to represent an octal value in Python 3.0, as in Python 2.6 (036), the compiler will throw an error.


4. Types of integers in Python 2.6: regular and long. Example

In Python 2.6, integers can be represented by two types:

  • regular (32-bit) numbers;
  • long (unlimited precision) numbers. Such numbers end with the character l or L. If the numeric value of an integer literal does not fit into a regular 32-bit number, then this value is automatically cast to a long integer. In this case, the interpreter automatically performs the corresponding conversion.


12345 # regular 32-bit number
1234567890l # long number in Python versions up to 3.0
7777777777777L # long number in Python versions up 3.0


5. Representation of integers in Python 3.0

In Python 3.0, both types of numbers (regular and long) were represented as a single (single) type of integers, which is automatically represented as a long integer (supports unlimited precision). Therefore, in this version of Python there is no need to complete literals with l or L. If you specify l or L after the number in Python 3.0, the interpreter will throw an “Invalid token” error.


6. Conversion functions of the numbers in the string, and vice versa hex(), oct(), bin(), int(). Examples

The following functions are used to turn the numeric form of a literal into a string:

  • hex(num) – converts the number num to a string that displays this number in hexadecimal notation;
  • oct(num) – converts the number num into a string that represents this number in octal;
  • bin(num) – converts the number num to a string that represents this number in binary.

To convert a string to an integer taking into account the calculus system, use the function

int(s, base)


  • s – a string;
  • base – an integer that determines the number of digits in the number system. For example, for calculus 7, the value base = 7.

Examples of conversion functions.

sh = hex(15) # sa = 0xF
so = oct(15) # sb = 0o17
sb = bin(15) # sb = 0b1111

i = int('15',10) # i = 15
i = int('15',8) # i = 13
# i = int('19',8) - error, the number 9 cannot be in the 8th calculus

i = int('2EF',16) # i = 751
i = int('20',16) # i = 32
i = int('14',5) # i = 9


7. Representation of real numbers. Example

Real numbers define floating point numbers. Real numbers (literals) can be represented as:

  • numbers that contain the separator of the integer and fractional part;
  • numbers that contain the character e or E to indicate the order of the number.

The Python interpreter recognizes a real number by the presence of the character ‘.’ (“dot”) or exponent (e or E). After the number is recognized, the corresponding object of a real type is created. Such an object is used in further mathematical expressions as an object of a real type (and not an object of an integer or another type).


2.85 # ordinary representation of a real number
3. # number 3.0
1.3e-3 # number 0.0013
1.52E6 # 1520000.0
3e2 # 300.0
2.0E-1 # 0.2


8. Complex numbers. Examples

Python has the ability to work with complex numbers. The general form for representing a complex number is as follows:

real_part + imag_part j


  • real_part – the real part of the complex number, which is optional (in the case when the number does not contain the real part);
  • imag_part – the imaginary part of the complex number, which ends with the character j or J.

The interpreter represents a complex number as two real numbers. When used in mathematical expressions, complex numbers are processed accordingly.

Examples of complex number literals



9. Creating complex numbers. Function complex(). Example

Complex numbers are created by the complex() function, which is a built-in Python function. General form of function:

complex(real, imag)


a = complex(6, -8) # a = (6-8j)
b = complex(0, 2.5) # b = 2.5j
c = complex(0.02, -1e4) # c = (0.02-10000j)


10. The eval() function. Converting a string to number

A number can be represented as a string, for example


You can use the eval() function to convert a string to a number. The eval(s) function considers the string s as Python code. The function compiles the string s and uses it. The string is considered as part of the program.


# Function eval()
# execution of a line as program code
a = 5
b = 6
c = eval('a+b') # c = a+b = 11

# converting strings represented as a number to the number itself
c = eval('0xF5') # c = 245
c = eval('0b111') # c = 7
c = eval('0o135') # c = 93

d = bin(eval('0b101')) # d = 0b101


Related topics