Values, Text, and First Programs

Numbers, operators, and names

The interpreter is a calculator before it is anything else, and typing expressions into it is the fastest way to learn how Python treats values. The operators +, -, * and / perform arithmetic, and parentheses group expressions:

>>> 2 + 2
4
>>> 50 - 5 * 6
20
>>> (50 - 5 * 6) / 4
5.0

Notice the last result. Whole numbers such as 2, 4 and 20 have type int; numbers with a fractional part such as 5.0 and 1.6 have type float. The / operator always returns a float, even when the division comes out even.

Three more operators complete the arithmetic set, and each answers a different question.

Mixing the two numeric types is allowed. When an operator has one integer operand and one float operand, Python converts the integer operand to floating point, so the result is a float:

>>> 4 * 3.75 - 1
14.0

The equal sign assigns a value to a name, and after an assignment the interpreter prints nothing before the next prompt:

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

A name only exists once it has been assigned. Using one that was never given a value raises NameError:

>>> n
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

That error is a spelling and ordering check as much as anything: it usually means a typo, or a line that runs before the line that defines the value.

Text and how to quote it

Python represents text with the type str, and single-quoted and double-quoted literals produce exactly the same kind of value:

>>> 'spam eggs'
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"
'Paris rabbit got your back :)! Yay!'

Because a quote character can also appear inside the text, there are two ways out. Escape it with a backslash, or choose the other quotation style so no escape is needed at all:

>>> 'doesn\'t'
"doesn't"
>>> "doesn't"
"doesn't"

The second version is easier to read, and picking the quote style that avoids escaping is usually the better habit.

There is a difference between how a string is stored and how it is shown. Echoing a value at the prompt shows the enclosing quotes and leaves escape sequences visible. print() omits the enclosing quotes and interprets the escaped special characters, so \n becomes an actual line break:

>>> s = 'First line.\nSecond line.'
>>> s
'First line.\nSecond line.'
>>> print(s)
First line.
Second line.

Sometimes the backslashes are the data — a Windows path, a regular expression — and interpreting them would destroy the value. A raw string, written with r before the opening quote, does not treat backslash-prefixed characters as special:

>>> print('C:\this\name')
C:  his
ame
>>> print(r'C:\this\name')
C:\this\name

One restriction comes with it: a raw string may not end in an odd number of backslashes. So a raw literal is the right tool whenever the backslashes must survive intact and the text does not finish on a lone backslash.

Joining and repeating text

Two operators build longer strings out of shorter ones: + concatenates and * repeats.

>>> 3 * 'un' + 'ium'
'unununium'

There is also a quieter rule. Two or more string literals written next to each other are concatenated automatically, which is the neat way to break a long message across lines:

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

That shortcut works only between literals. A variable or an expression must be joined with +, so prefix 'thon' is a syntax error while prefix + 'thon' gives 'Python'.

Reaching inside a string

Strings can be indexed, and indexing starts at zero. Negative indices count from the right, starting at -1, which saves you from computing a length just to reach the last character:

>>> word = 'Python'
>>> word[0]
'P'
>>> word[-1]
'n'
>>> word[-2]
'o'

Since -0 is the same as 0, negative indices necessarily begin at -1 rather than at zero.

Slicing takes a range instead of one position, and the rule that decides every slice is: the start is included and the end is excluded.

>>> word[0:2]
'Py'
>>> word[2:5]
'tho'

That convention is what makes word[:2] + word[2:] rebuild the original string with nothing duplicated and nothing lost. An omitted first index defaults to zero and an omitted second index defaults to the length of the string.

Out-of-range positions behave differently depending on what you asked for:

So a stray index is reported loudly, while a slice that overshoots is simply trimmed to what is there.

Strings never change

Python strings are immutable: once built, their contents cannot be edited in place. Assigning to an indexed position therefore raises TypeError rather than quietly replacing a character:

>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

The supported move is to create a new string out of the pieces you want:

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

Nothing was edited there: two new values were built from slices and fresh text, and the original word is untouched.

Lists hold items, and let you change them

A list is written as comma-separated items between square brackets. Its items may be of different types, although in practice they usually share one:

>>> squares = [1, 4, 9, 16, 25]
>>> squares[0]
1
>>> squares[-3:]
[9, 16, 25]

Lists are indexed and sliced just like strings, with one useful difference: a list slice returns a new list, not a view onto the old one.

Unlike strings, lists are mutable, and there are three distinct ways to change one:

Slice assignment can even change the size of the list: letters[2:5] = [] removes those items, and letters[:] = [] clears the list entirely.

>>> cubes = [1, 8, 27, 65, 125]
>>> cubes[3] = 64
>>> cubes.append(216)
>>> cubes
[1, 8, 27, 64, 125, 216]

Two names, one list

Simple assignment never copies data. When you assign a list to a variable, that variable refers to the existing list, so a change made through either name is visible through the other:

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> rgba.append("Alph")
>>> rgb
['Red', 'Green', 'Blue', 'Alph']

When you actually want an independent list, ask for one. Every slice operation returns a new list, so a full slice makes a shallow copy that can be edited without touching the original:

>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"

Sharing is the default; copying is the deliberate act.

A first program: state, repetition, output

A short Fibonacci program brings together everything a program needs: values that change, a loop that repeats, and output.

>>> a, b = 0, 1
>>> while a < 10:
...     print(a)
...     a, b = b, a + b
...
0
1
1
2
3
5
8

The first line is a multiple assignment: a and b receive 0 and 1 at once. The same line appears inside the loop, where the order of operations matters: every expression on the right-hand side is evaluated before any assignment takes place, and those expressions are evaluated from left to right. That is what lets a, b = b, a + b use the old a while computing the new b.

The while loop repeats as long as its condition remains true, and indentation is how Python groups the statements of its body. Every line of one block must be indented by the same amount.

The condition does not have to be a comparison. Truth follows a simple rule:

So while count: keeps looping while count is not zero, and stops on its own when the countdown reaches zero.

print() writes the values it is given. It differs from simply echoing an expression: strings are printed without quotes, and a space is inserted between multiple items.

>>> i = 256 * 256
>>> print('The value of i is', i)
The value of i is 65536

Its end keyword replaces the final newline with whatever you supply, which turns one value per line into a single running line:

>>> a, b = 0, 1
>>> while a < 1000:
...     print(a, end=',')
...     a, b = b, a + b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

What a float actually stores

Floating-point numbers are held in hardware as base-2 fractions, and most decimal fractions cannot be represented exactly as binary fractions. The decimal floats you type are therefore stored as the nearest available binary approximation. In base 2, one tenth is an infinitely repeating fraction; stop at any finite number of bits and what remains is an approximation.

Most people never notice, because of how values are shown. Python prints a rounded decimal form of the stored binary approximation. The true decimal value stored for 0.1 begins 0.1000000000000000055511151231257827…, which is more digits than anyone needs, so the prompt displays 0.1 instead.

The display is a courtesy, not a correction. The stored value is unchanged: it is still the nearest representable binary fraction.

String formatting can limit the digits shown — either significant digits or digits after the decimal point — and it changes only the presentation:

>>> format(math.pi, '.12g')
'3.14159265359'
>>> format(math.pi, '.2f')
'3.14'

None of that alters what is in memory. Rounding the display of a final result is exactly the right move for a report, and exactly the wrong move for a comparison.

Comparing values that are only close

One illusion begets another. Because 0.1 and 0.3 each carry their own approximation, adding 0.1 three times does not compare equal to 0.3:

>>> 0.1 + 0.1 + 0.1 == 0.3
False

Rounding the operands first does not help, because neither 0.1 nor 0.3 can get any closer to its intended exact value than it already is:

>>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)
False

The tool for the job is math.isclose(), which compares inexact values without demanding that they match bit for bit:

>>> math.isclose(0.1 + 0.1 + 0.1, 0.3)
True

Keep the two needs separate. Formatting decides what a report shows; math.isclose() decides whether two computed results agree.

And note what this is not: representation error is a property of binary floating-point arithmetic, not a defect in Python or in your code. The same behavior appears in every language that uses the same floating-point hardware.

Key takeaways

• Division splits three ways: / always returns a float, // returns the floored quotient, % returns the remainder, and ** raises to a power; mixing an int with a float converts the int.
• A name must be assigned before it is used, or Python raises NameError.
• Quoting is a choice, escaping is a fallback: print() drops the enclosing quotes and interprets escapes, while a raw string keeps backslashes literal and may not end in an odd number of them.
• Indexing starts at zero and slices exclude their end: a bad index raises IndexError, but an overshooting slice is trimmed silently.
• Strings are immutable and lists are mutable: indexed assignment fails on a string but replaces an item in a list, where append() and slice assignment also work.
• Ordinary list assignment shares one object; a full slice is what makes a copy.
• A first program combines state, repetition and output: multiple assignment, an indented while body, and print() with its end keyword.
• A short display hides a binary approximation, so compare inexact results with math.isclose() rather than ==.