A type is a class of values that a Python program can work with. We've worked with strings, which constitute one type, and numbers, which constitute… well, actually they constitute two types, integers and floating-point numbers.
The difference between integers and floating-point numbers is in how they are represented internally, which has an effect on their behavior. Integers are whole numbers like 4359, 0, and −10, with no decimal point or fractional value. Floating-point numbers can have a decimal point, but unlike integers they are approximations (though correct to fifteen decimal places). Note that there is a floating-point number 2.0 — it has no fractional part, but the floating-point representation can work with it.
How does Python decide whether a number is an integer or
floating-point value? First, in how you type it: If you type it
with a decimal point (like 2.0), it is a floating-point value,
but a non-decimal number (like 2) is an integer.
When you perform arithmetic on two integers, you get an integer
as a result — unless you do regular division using
/’, in which case you get a floating-point
result. If you perform arithmetic where one or the other
side is floating-point, you get a floating-point result.
On the whole, you don't have to worry about this distinction
between integers and floating-points, but every once in a while
the difference will rear its ugly head. For example,
2 ** 2000” and “
2.0 ** 2000”
work very differently: The first gives you the number you expect,
while the second results in an overflow error, since
the floating-point representation isn't built for numbers beyond
approximately 1.8 × 10308.
Sometimes you have values of one type that you want to convert into a value of another type. For that, Python has several “conversion functions”.
the conversion of
xto a floating-point number
the conversion of
xto an integer
the conversion of
xto a string
Some examples of using these conversion functions.
digits = '234'
num = int(digits) # num is now 234, digits is still string '234'
digits2 = 2 * digits # digits2 is now the string '234234'
num2 = 2 * num # num2 is now the integer 468
num2f = 2 * float(digits) # num2f is the floating-point number 468.0
result = 'Doubled: ' + str(2 * num) # result is 'Doubled: 468'
That last line is notable: Python will not allow you to add
a string and a number, so
result = 'Doubled: ' + (2 * num)”
will simply lead Python to reject the program with a run-time error.
To get the number 468 treated as a string that can be added to
another, we need to use the
Sometimes we want to interact with the user. The easiest approach to this is a typewriter-like interface, used by old-style computers: Sometimes the program displays new text for the user to see, and at other times the program reads a line typed from the user. Python supports this type of interface using two functions.
returns the next line of user input, as a string
xon the screen (no return value)
Here is a very simple program using these.
print('What is your name?')
name = input()
print('Hi, ' + name + '!')
When executed, this is what appears (user input in boldface):
What is your name? Somebody Hi, Somebody!
Since we'll often want to read a number from the user, it can
be helpful to use the
float function in conjunction
print('How old are you?')
age = int(input())
print('Next year you will be ' + str(age + 1))
Here is a sample run.
How old are you? 20 Next year you will be 21
In execution, the
input function returns the string
typed by the user — the digits 2 and 0 — which the
program passes as an argument to
int, which returns the
number 20. In the third line, we compute 20 + 1, then
pass the result of 21 to
str to get the string with the
digits 2 then 1, which is then added to another string.
The usage of
str is important:
Python will not allow us to add a string and an integer together.