
Data TypesThis is the first of several lessons on the data types used by Python. Computer programs can process instructions that work with many different kinds of data, and the instructions need to be very precise. If you add a word to this sentence, 'add' means something very different from when you add 2 and 3. A computer language has to have a set of rules defining what operations can be applied to different kinds of data, and for this to work, there also has to be a set of rules defining exactly what data can be used with each operation. For example, if you want to calculate grossProfit = salesIncome  costs, a program has to know that these quantities are variables containing numbers rather than just strings of letters. They must have a numerical data type rather than string data type. If you are not clear about the meaning in computer science of variables and of data types, it may help to brush up on the lesson Introduction_to_Programming/Variables. 
Introduction to integersPython has several data types to represent numbers. This lesson introduces two: integers, and floating point numbers, or 'floats'. We'll discuss floats later in the lesson. An integer, commonly abbreviated to int, is a whole number (positive, negative, or zero). So >>> isinstance(7, int)
True
>>> isinstance(0, int)
True
>>> isinstance(11, int)
True
>>> isinstance(2, int)
True
>>> isinstance(5, int)
True
>>> isinstance(3.14159, int)
False
>>> isinstance(0.0001, int)
False
>>> isinstance(11.11111, int)
False
>>> isinstance(2.0, int)
False
>>> 2+2
4
>>> 42
2
>>> 6+1
7
>>> 6+73
10
>>> 2*2
4
>>> 2*2*2
8
>>> 2
2
>>> 8/2
4.0
>>> 4*4/2
8.0
>>> 44*2
4
>>> 24
2
>>> 10+10/2
15.0
You can do more mathematical operations than the previously demonstrated ones. We can perform a floor division by using two forward slashes ( >>> 4 // 2
2
>>> 1 // 8
0
>>> 5 // 5
1
>>> 100 // 5
20
>>> 4 // 3
1
>>> 5 % 4
1
>>> 1 % 4
1
>>> 4 % 4
0
>>> 2 % 4
2
>>> 2 % 1
0
>>> 20 % 2
0
>>> 20 % 3
2
>>> 20 % 3
1
The >>> divmod(7,3)
(2, 1)
>>> (q,r) = divmod(7,3)
>>> q; r
2
1
You can also find the power of a number by using two asterisk symbols ( >>> 4 ** 2
16
>>> 4 ** 4
256
>>> 1 ** 11278923689
1
>>> 2 ** 4
16
>>> 10 ** 2
100
>>> 1024 ** 2
1048576
>>> 10 ** 6
1000000
>>> 25 ** (1/2)
0.2
>>> 4 *  3 ** 2
36
>>> 4 * ( 3) ** 2
36
>>> 8 / 4 ** 2
0.5
The operator of exponentiation If unsure of precedence, you can always use parentheses to force the desired result: >>> (4 * ( 3)) ** 2
144
There is no limit for the length of integer literals apart from what can be stored in available memory. Nondecimal IntegersAlmost everyone is familiar with ten based numbers. While base 10 is useful for everyday tasks, it isn't ideal for use in the computer world. Three other numeral systems are commonly used in computer science; binary, octal, and hexadecimal. We'll lightly cover Python's use of these in this section. The binary system is essential as all information is represented in binary form in computer hardware. Octal and hexadecimal are convenient for condensing binary numbers to a form that is more easily read by humans, while (unlike decimal) being simple to translate to or from binary. If you have difficulty with this part of the lesson, it may help to brush up on the lesson Numeral_systems in the course Introduction_to_Computers. Most people have heard of binary and it is often associated with computers. Actually, modern binary made its way into the world far before electricity was widely in use. The binary system is 2 based, which means that only two numbers are used. Of course, these numbers are 0 and 1. So unlike the decimal's To use binary numbers in python, prepend >>> 0B11
3
>>> 0B1 + 0B1
2
>>> 0B11 + 0B1
4
>>> 0B10001 + 0B1
18
>>> 0B10001  0B1
16
>>> bin(2345)
'0b100100101001'
>>> 0b_111_0101_0011
1875
The value returned by
>>> 0o3
3
>>> 0o12
10
>>> 0o12 + 0o10
18
>>> 0o12  0o03
7
>>> 0o100
64
>>> 0o777
511
>>> 0o777  0o111
438
>>> oct(1_234_987)
'0o4554053'
>>> 0o_1234_9876
File "<stdin>", line 1
0o_1234_9876
^
SyntaxError: invalid token
>>> 0o_1234_0765
2736629
>>> 0xF
15
>>> 0xF0
240
>>> 0xFF  0xF
240
>>> 0xF + 0xA
25
>>> 0x2 + 0x2
4
>>> 0x12  0xA
8
>>> 0xFF / 0xF
17.0
>>> 0xF * 0xF
225
>>> hex(1_234_987)
'0x12d82b'
>>> 0x_12_D82B
1234987
Bitwise OperatorsAll integers may be tested or modified by the Bitwise Operators: These operators are called 'bitwise' because they operate on individual bits within the integer.
>>> bin (0b1010101 & 0b1111)
'0b101'
>>> bin (0b1010101 & 0b111000)
'0b10000'
>>> hex (0xFF00FF & 0xFF00)
'0x0'
In the first example both input operands 0b1010101
0b 1111
^ ^
'0b101'.
>>> bin (0b1010101  0b1110)
'0b1011111'
>>> bin (0b1010101  0b1100)
'0b1011101'
>>> hex (0xFF00FF  0x3F0)
'0xff03ff'
In the first example both input operands 0b1010101
0b 1110
^ ^^^^^
'0b1011111'.
>> bin (0b1010101 ^ 0b1110)
'0b1011011'
>>> bin (0b1010101 ^ 0b1100)
'0b1011001'
>>> hex (0xFF00FF ^ 0x3F0)
'0xff030f'
In the first example both input operands 0b1010101
0b 1110
^ ^^ ^^
'0b1011011'.
>> bin(0b10101 << 2)
'0b1010100'
>>> bin(0b10101 << 5)
'0b1010100000'
>>> hex(0xFF00FF << 8)
'0xff00ff00'
>>> (0xFF00FF << 8) == (0xFF00FF * 2**8)
True
In the first example the output is the input shifted left 2 bits: 0b 10101
0b1010100
^^
>> bin(0b10101 >> 2)
'0b101'
>>> bin(0b10101 >> 5)
'0b0'
>>> hex(0xFF00FF >> 8)
'0xff00'
>>> (0xFF00FF >> 8) == (0xFF00FF // 2**8)
True
In the first example the output is the input shifted right 2 bits: 0b10101
0b 101
twoBits = operand & 0x3
The bitwise operators above perform as expected on all integers of (almost) unlimited length: >>> hex( ( 0x1234_FEDC << 120 )  ( 0x_CDE_90AB << 60 ) )
'0x1234fedc00000000cde90ab000000000000000'
>>> hex( ( 0x1234_FEDC << 200 ) ^ ( 0x_CDE_90AB << 207 ) )
'0x67d7cab5c00000000000000000000000000000000000000000000000000'
6. The behavior of the invert (~) operator shows that negative numbers are treated as their 2's complement value: >>> a = 0b1100101100101 ; bin(~a)
'0b1100101100110'
For a true 1's complement bitwise invert here is one way to do it: >>> a = 0b1100101100101 ; b = a ^ ( (1 << a.bit_length)  1 ); bin(b)
'0b11010011010'
>>> c = a + b; bin(c)
'0b1111111111111' # to test the operation, all bits of c should be set.
>>> (c+1) == ( 1 << (c.bit_length) )
True # they are.
And another way to do it: from decimal import *
a = 0b11100100011001110001010111 # a is int
b = bin(a) # b is string
print ('a =', b)
formerPrecision = getcontext.prec
getcontext.prec = a.bit_length
d = Decimal.logical_invert( Decimal( b[2:] ) ) # d is string
getcontext.prec = formerPrecision
print ('d =', d)
e = int(str(d),2) # e is int
print ('e =', bin(e))
( (a + e) == ( ( 1 << a.bit_length )  1 ) ) and print ('successful inversion')
When you execute the above code, you see the following results: a = 0b11100100011001110001010111
d = 11011100110001110101000
e = 0b11011100110001110101000
successful inversion
The Decimal.logical_invert performs a 1's complement inversion. 
Introduction to floatsAlthough integers are great for many situations, they have a serious limitation, integers are whole numbers. This means that they are not real numbers. A real number is a value that represents a quantity along a continuous line^{[5]}, which means that it can have fractions in decimal forms. >>> isinstance(4.5, float)
True
>>> isinstance(1.25, float)
True
>>> isinstance(0.75, float)
True
>>> isinstance(3.14159, float)
True
>>> isinstance(2.71828, float)
True
>>> isinstance(1.0, float)
True
>>> isinstance(271828, float)
False
>>> isinstance(0, float)
False
>>> isinstance(0.0, float)
True
The basic arithmetic operations used for integers will also work for floats. (Bitwise operators will not work with floats.) >>> 4.0 + 2.0
6.0
>>> 1.0 + 4.5
3.5
>>> 1.75  1.5
0.25
>>> 4.13  1.1
3.03
>>> 4.5 // 1.0
4.0
>>> 4.5 / 1.0
4.5
>>> 4.5 % 1.0
0.5
>>> 7.75 * 0.25
1.9375
>>> 0.5 * 0.5
0.25
>>> 1.5 ** 2.0
2.25
Some technical information about 'floats.'A floating point literal can be either pointfloat or exponentfloat.
34.45 ; 34. ; .45 ; 0. ; .00 ; 33. ;
e9 ; e0 ; e+1 ; E2 ; E3 ; E+4. The exponent is interpreted as follows:
decinteger exponent, for example: 0e0 ; 3e1 ; 15E6; or pointfloat exponent, for example: .5E+2 ; 3.00e5 ; 123_456.75E5 ;
The Precision of FloatsBefore you start calculating with floats you should understand that the precision of floats has limits, due to Python and the architecture of a computer. Some examples of errors due to finite precision are displayed below. >>> 1.13  1.1
0.029999999999999805
>>> 0.001 / 11.11
9.000900090009002e05
>>> 1 + .0000000000000001
1.0
>>> 5.5 % 3.2
0.9000000000000004
>>> float(1_234_567_890_123_456)
1234567890123456.0
>>> float(12_345_678_901_234_567)
1.2345678901234568e+16
In the second example, In the third example, the sum of the addends The fourth example gives the correct result if rewritten: >>> ((5.5*10 ) % (3.2*10)) / 10.0
0.9
When working with Python floats, we need to be aware that there will probably be a margin of error. Decimal fixed point and floating point arithmetic for extreme precisionThe Python "Decimal" module provides support for fast correctlyrounded decimal floating point arithmetic. The module offers several advantages over the float datatype, including:
The usual start to using decimals is importing the module, viewing the current context with getcontext and, if necessary, setting new values for precision, rounding, or enabled traps: >>> from decimal import *
>>> getcontext
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=999999, Emax=999999, capitals=1, clamp=0, flags=[Inexact, FloatOperation, Rounded], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> setcontext(ExtendedContext)
>>> getcontext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[])
>>> setcontext(BasicContext)
>>> getcontext
Context(prec=9, rounding=ROUND_HALF_UP, Emin=999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[Clamped, InvalidOperation, DivisionByZero, Overflow, Underflow])
>>> c = getcontext
>>> c.flags[Inexact] = True
>>> c.flags[FloatOperation] = True
>>> c.flags[Rounded] = True
>>> getcontext
Context(prec=9, rounding=ROUND_HALF_UP, Emin=999999, Emax=999999, capitals=1, clamp=0, flags=[Inexact, FloatOperation, Rounded], traps=[Clamped, InvalidOperation, DivisionByZero, Overflow, Underflow])
>>> getcontext.prec = 75 # set desired precision
>>> getcontext
Context(prec=75, rounding=ROUND_HALF_UP, Emin=999999, Emax=999999, capitals=1, clamp=0, flags=[Inexact, FloatOperation, Rounded], traps=[Clamped, InvalidOperation, DivisionByZero, Overflow, Underflow])
We are now ready to use the decimal module. >>> Decimal(3.14) # Input to decimal is float.
Decimal('3.140000000000000124344978758017532527446746826171875') # Exact value of float 3.14.
>>> Decimal('3.14') # Input to decimal is string.
Decimal('3.14') # Exact value of 3.14 in decimal floating point arithmetic.
>>> (2 ** 0.5)**2
2.0000000000000004 # Result of binary floating point operation. We expect 2.
>>> (Decimal('2') ** Decimal('0.5')) ** Decimal('2')
Decimal('1.99999999999999999999999999999999999999999999999999999999999999999999999999')
# Result of decimal floating point operation with string input. We expect 2.
>>> (2.12345678 ** (1/2.345)) ** 2.345
2.1234567800000006 # Result of floating point operation. We expect 2.12345678.
>>> (Decimal('2.12345678') ** (Decimal('1')/Decimal('2.345'))) ** Decimal('2.345')
Decimal('2.12345677999999999999999999999999999999999999999999999999999999999999999999')
# Result of decimal floating point operation with string input . We expect 2.12345678.
>>> getcontext.rounding=ROUND_UP
>>> (Decimal('2.12345678') ** (Decimal('1')/Decimal('2.345'))) ** Decimal('2.345')
Decimal('2.12345678000000000000000000000000000000000000000000000000000000000000000003')
# Result of decimal floating point operation with string input . We expect 2.12345678.
Some mathematical functions are also available to Decimal: >>> getcontext.prec = 30
>>> Decimal(2).sqrt
Decimal('1.41421356237309504880168872421')
>>> (Decimal(2).sqrt)**2
Decimal('2.00000000000000000000000000001') # We expect 2.
>>> Decimal(1).exp
Decimal('2.71828182845904523536028747135') # Value of 'e', base of natural logs.
>>> Decimal( Decimal(1).exp ).ln
Decimal('0.999999999999999999999999999999') # We expect 1.
Lack of precision in the real world(included for philosophical interest) >>> a = 899_999_999_999_999.1 ; a  (a  .1)
0.125
>>> 1.13  1.1
0.029999999999999805
Simple tests indicate that the error inherent in floating point operations is about This raises the question "How much precision do we need?"
Extreme Precision(included for historical interest) If you must have an answer correct to 30 places of decimals, Python's integer math comes to the rescue. Suppose your calculation is:
and you want 30 significant digits after the decimal point. Your calculation becomes:
The correct result

In Python and most languages, a Boolean can be either >>> 1 == 1
True
>>> 1 == 0
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(10001219830)
True
>>> bool(1908)
True
>>> bool("Hello!")
True
>>> bool("")
False
>>> bool(" ")
True
>>> bool(None)
False
>>> bool(0.000000000000000000000000000000000)
False
>>> bool("0.000000000000000000000000000000000")
True
>>> bool(0.0)
False
>>> bool([])
False
>>> bool([1, 2, 3])
True
>>> bool
False
>>> bool(True)
True
>>> bool(False)
False
>>> bool(1==1)
True
>>> bool(1==0)
False
You can also use three operators to alter a Boolean statement^{[7]}: >>> not False
True
>>> not True
False
>>> True and True
True
>>> True and False
False
>>> True or False
True
>>> False or False
False
>>> not(False or False)
True
>>> not(False and False)
True
>>> not(False and True)
True

A complex number is represented as >>> 1+2j
(1+2j)
>>> 1+5.5j
(1+5.5j)
>>> 0+5.5j
5.5j
>>> 2j
2j
>>> 1+0j
(1+0j)
>>> complex(3,2)
(32j)
Note also that j cannot be used on its own without b. If you try to use j on its own, Python will look for a variable >>> a = 5 + 3j
>>> a  j
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'j' is not defined
>>> a  1j
(5+2j)
>>> j = 3j
>>> a  j
(5+6j)
>>> a  1j
(5+2j)
The last result illustrates that even when the variable j has a numerical value, 1j (where, as above, can be any number) is always interpreted as the imaginary number j, not the variable j.
>>> (1+3j)+(25j)
(32j)
>>> (1+3j)(25j)
(1+8j)
>>> (1+3j)*(25j)
(17+1j)
>>> a = complex(3,5) ; b = 1 ; b += 2j ; a ; b
(35j)
(1+2j)
>>> a + b ; a  b
(43j)
(27j)
>>> a * b ; a / b
(13+1j)
(1.42.2j)
>>> a + 4 ; b  2j ; a * 3.1 ; b / 2
(75j)
(1+0j)
(9.315.5j)
(0.5+1j)
>>> b ; b /= 5 ; b
(1+2j)
(0.2+0.4j)
>>> a = complex(3,5j) ; a
(80j)
Look closely at the last example. It does not produce an error, but is it what you want?
>>> (1+2j).real
1.0
>>> (1+2j).imag
2.0
>>> var = 5+3j
>>> var.real
5.0
>>> var.imag
3.0

IntroductionSince integers and floats can't be mixed together in some situations, you'll need to be able to convert them from one type to another. Luckily, it's very easy to perform a conversion. To convert a data type to an integer, use the >>> int(1.5)
1
>>> int(10.0)
10
>>> int(True)
1
>>> int(False)
0
>>> int('0xFF', base=16) ; int('0xF1F0', 16) ; int('0b110100111', 0) ; int('11100100011',2)
255
61936
423
1827
>>> int("100")
100
>>> float(102)
102.0
>>> float(932)
932.0
>>> float(True)
1.0
>>> float(False)
0.0
>>> float("101.42")
101.42
>>> float("4")
4.0
>>> bool(1)
True
>>> bool(0)
False
>>> bool(0.0)
False
>>> bool(0.01)
True
>>> bool(14)
True
>>> bool(14+3j)
True
>>> bool(3j)
True
>>> bool(0j)
False
>>> bool("")
False
>>> bool("Hello")
True
>>> bool("True")
True
>>> bool("False")
True
>>> complex(True)
(1+0j)
>>> complex(False)
0j
>>> complex(3, 1)
(3+1j)
>>> complex(1, 22/7)
(1+3.142857142857143j)
>>> complex(0, 1.5)
1.5j
>>> complex(7, 8)
(7+8j)
>>> complex("1")
(1+0j)
>>> complex("1+4j")
(1+4j)
>>> complex("9.75j")
9.75j
Converting integers, decimal to nondecimalThis conversion is from int to str representing int: >>> a = 12345678901234567890
>>> b = bin(a) ; b
'0b1010101101010100101010011000110011101011000111110000101011010010'
>>> h = hex(a) ; h
'0xab54a98ceb1f0ad2'
>>> o = oct(a) ; o
'0o1255245230635307605322'
>>>
Converting integers, nondecimal to decimalThis conversion is from str representing int to int: >>> a;b;h;o
12345678901234567890
'0b1010101101010100101010011000110011101011000111110000101011010010'
'0xab54a98ceb1f0ad2'
'0o1255245230635307605322'
>>>
>>> int(b,base=0) == int(b,base=2) == int(b,0) == int(b,2) == a # Base 0 or correct base is required.
True
>>> int(h,16) == a
True
>>> int(o,8) == a
True
>>>
>>> int ('ab54a98ceb1f0ad2', 16) == a # When base 16 is supplied, the prefix '0x' is not necessary.
True
>>>
>>> eval(b) == a # Function eval(...) provides simple conversion from str to base type.
True
>>> eval(h) == a
True
>>> eval(o) == a
True
>>>
>>> int('12345678901234567890',0) == int('12345678901234567890',base=0) == a
True
>>> int('12345678901234567890',10) == int('12345678901234567890',base=10) == a
True
>>> eval('12345678901234567890') == int('12345678901234567890') == a
True
>>>
Converting


8. Python's builtin functions:
"abs", "bin", "bool", "complex", "divmod", "eval(expression, ....)", "float", "hex", "int", "oct", "pow", "round", "sys.float_info", "sys.int_info"
9. Python's documentation:
"3.1.1. Numbers", "Numeric Types", "Integer literals", "Floating point literals", "Imaginary literals", "Operator precedence", "Why are floatingpoint calculations so inaccurate?", "15. Floating Point Arithmetic: Issues and Limitations", "9.4. decimal  Decimal fixed point and floating point arithmetic", "4.4.2. Additional Methods on Integer Types"
Manage research, learning and skills at IT1me. Create an account using LinkedIn to manage and organize your IT knowledge. IT1me works like a shopping cart for information  helping you to save, discuss and share.