Did you know? Programmers convert coffee to code.

If you like my articles, sponsor me a coffee.

At the other end of the link I post some results of my other hobbies, like playing bass. It is worth checking it out ;)

Numbers and Strings in Python 3

In this article we will have a look at numbers and strings because they are the base of development with Python.

This article is an excerpt of my book Python 3 in Anger. For a more detailed version take a look at the book.


As you might already think, number data types store numeric values like integers and floating point numbers. Although there is one more types of numbers you should know about: complex numbers. Let’s take a brief look at these three types of numbers.

  • Integers (called ints too) are whole numbers without decimal points and can contain a positive or negative number. Integers can be as long as you wish providing good calculation possibilities[^longs].
  • Floats are floating point numbers, this means they contain a decimal point along with them even if they are whole numbers. They cover the set of real numbers so you can do any operation on them.
  • Complex numbers is for scientific purposes most of the time. But it is good to know there is something more. You probably know from maths that complex numbers are represented as a + bi where i is the imaginary part which represents the square root of -1. In Python however the imaginary part is represented as a j so if you want to have a complex number written you should do: c = 42+26j.

Special numbers

There are two commonly used (well, in mathematics at least) numbers which you can use in Python too. These number are pi and e. To use them, you have to import math module:

>>> import math
>>> math.pi
>>> math.e

Random numbers

When starting developing with the help of some books or tutorials you can encounter random number generation. We will use random numbers later. However it is a good time to introduce random number generation with Python.

For this we have to import a module: random.

>>> import random
>>> random.choice((1,2,3,4,'a')) # chooses one item of the provided list, tuple or string (it has to be an idexable object)
>>> random.random() # returns a random floating point number which is greater or equal to `0` and less than `1`
>>> l = [1,2,3,4,5]
>>> random.shuffle(l) # shuffles the list in place, returns `None`
>>> l
[1, 4, 3, 2, 5]
>>> random.randrange(1,10) # selects a random integer between the range of the first and the second parameter
>>> random.randrange(1,10,2) # the third parameter is an optional integer, defines the step in the range to select the elements from


Strings are in Python defined as a list of characters represented between quotation marks. We can use a single quote (‘ or apostrophe) or a double quote (“) to denote strings. We can use one within the other however if you start a string with a single quote you have to end it with it too.

These strings are single line strings, meaning you cannot spread them among multiple lines, you will get an error. However there is the string starting with three quotes (again single quote or double quote does not matter) we discussed when talking about comments. They can spread through multiple lines. However they are converted to regular strings at the end and have only the line-break character (\n) where you hit return when writing the text. The most common use of such a string is documentation. We will talk about this topic when we arrive at functions and classes.

Let’s have a quick example:

>>> "this is a
File "<;stdin>", line 1
"this is a
SyntaxError: EOL while scanning string literal
>>> ''' this is a
... string'''
' this is a\nstring'

Accessing and updating strings

Python does not have an explicit type of characters, they are treated as strings with a length of one. Accessing strings is the same than accessing any other variable.

Updating strings in-place is not an options because strings are immutable types in Python. If you “update” the value of a string you are only reassigning the value with a new string.

>>> s1 = "Hello World!"
>>> id(s1)
>>> s1 = "Hello Python!"
>>> id(s1)
>>> id('Hello World!')

Special string operators

Because strings are types in Python which are treated as some kind of lists, strings have special operators which we can use for our development purposes. Let’s have a look at them with examples.

A detailed description on slicing follows in the next sub-section.

>>> 'Hello' + ' ' + "Python" # the + sign concatenates the strings
'Hello Python'
>>> 'Hello'+'!' * 5 # the * sign creates multiple copies of the string
>>> "Python"[2] # slices the character at the given position out of the string
>>> "Hello World!"[0:5] # gets the characters between the given range
>>> 'Hello World!'[::2] # gets the characters between the given range with the amount of steps between the characters
>>> 'llo' in "Hello World!" # looks up if a substring is present in the string
>>> "hell" not in 'Hello World!' # looks if a substring is not present in the string

Triple quotes

I’ve already mentioned my opinion about triple quotes: they are multiline strings and not comments.

Being a multiline string means that they print the same as single-line (or normal) strings but they preserve their explicit new lines and convert the special escape characters to their printed version.

>>> spam = """Spam, Spam, Spam, lovely Spam
... Wonderful Spam, Lovely Spam.
... Spam, Spam, Spam, magnificent Spam,
... \tSuperlative Spam.
... Spam, Spam, Spam, wonderous Spam,\nSurgical Spam, splendiferous Spam.
... Eggs, Bacon, sausage!\rSpam, Spam, Spam, Spaaam!"""
>>> spam
'Spam, Spam, Spam, lovely Spam\nWonderful Spam, Lovely Spam.\nSpam, Spam, Spam, magnificent Spam,\n\tSuperlative Spam.\nSpam, Spam, Spam, wonderous Spam,\nSurgical Spam, splendiferous Spam.\nEggs, Bacon, sausage!\rSpam, Spam, Spam, Spaaam!'
>>> print(spam)
Spam, Spam, Spam, lovely Spam
Wonderful Spam, Lovely Spam.
Spam, Spam, Spam, magnificent Spam,
Superlative Spam.
Spam, Spam, Spam, wonderous Spam,
Surgical Spam, splendiferous Spam.
Spam, Spam, Spam, Spaaam!

As you can see, when not printing the string he special escape characters stay escaped — and even where we added a newline when creating the multiline-string Python explicitly displays the \ns.

String formatting

String formatting is cool in Python. There are two versions of formatting: with the % sign (which is similar to C’s printf method) and the format() method of the string itself. I will introduce both however in most of the cases the second version is better and easier to use.

Let’s jump right into the details.

>>> name = 'Gabor'
>>> age = 31
>>> 'My name is %s and I am %d years young!'%(name, age)
'My name is Gabor and I am 31 years young!'
>>> 'My name is {} and I am {} years young!'.format(name, age)
'My name is Gabor and I am 31 years young!'
>>> 'My name is {0} and I am {1} years young!'.format(name, age)
'My name is Gabor and I am 31 years young!'

As you can see, there is not much of a difference between the two formatting options. However if you look at the first version, you can see that I used different placeholders (%s and %d) for the variables than in the second version.

The key is that for the % formatting you have to tell the type of the parameters to enable python according format in the resulting string. This means too that you have to repeat variables if you want to print them more than once.

The format function works with the parameter-indexes and works out the formatting based on the type. So you do not have to explicitly mention what type the parameter is. And if you provide the same amount of parameters as placeholders you can leave the parameter indexes.

>>> 'My name is %s and I am %d years young and I have read %d books!'%(name, age, age)
'My name is Gabor and I am 31 years young and I have read 31 books!'
>>> 'My name is {} and I am {} years young and I have read {} books!'.format(name, age)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> 'My name is {} and I am {} years young and I have read {} books!'.format(name, age, age)
'My name is Gabor and I am 31 years young and I have read 31 books!'
>>> 'My name is {0} and I am {1} years young and I have read {1} books!'.format(name, age)
'My name is Gabor and I am 31 years young and I have read 31 books!'

It is up to you which formatting you use later on, however in this article series I will stick to the format function. However if you like the % better here are some characters and what they do in the format-string:

  • %c: character
  • %s: string conversion via str() prior to formatting
  • %i: signed decimal integer
  • %d: signed decimal integer
  • %u: unsigned decimal integer
  • %o: octal intege
  • %x: hexadecimal integer (lowercase letters)
  • %X: hexadecimal integer (uppercase letters)
  • %e: exponential notation (with lowercase ‘e’)
  • %E: exponential notation (with uppercase ‘E’)
  • %f: floating point real number
  • %g: the shorter of %f and %e
  • %G: the shorter of %f and %E
Share the knowledge!

Senior developer, consultant, author, mentor, apprentice. I love to share my knowledge and insights what I achieve through my daily work which is not trivial -- at least not for me.

Click Here to Leave a Comment Below

%d bloggers like this: