Python supports several different types of values. These values are what variables can be assigned to. Thus far, we've encountered, strings and numeric values such as integers.

Numeric Values – Integers

Mathematically, integers are whole numbers that are either positive or negative. The same definition is applicable for Python integers.

Here is an example of an integer expression in Python. As we saw earlier, Python echoes whatever you write in the interactive shell:

Python 3.6.0 (default, Dec 24 2016, 08:01:42)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 7
7
>>>

We also saw the different symbols, such as +, *, and -, that can be used to perform different arithmetic operations on the integer values:

>>> 5 + 4 + 6 + 9
24
>>> 5 * 5
25
>>> 42 - 16
26
>>>

We can also check the type of a value by using the type function that's built into Python:

There are a few other numeric types of values, such as floating-point numbers, but we'll be taking a look at those in the next chapter.

String Values

Another type of value that we've seen in the previous section was a string value. This is a sequence of characters that's placed in between two quotation marks, for example, "January", "Chops Maloy", and 'UB40'. You can use both double and single quotes to denote strings. Strings can contain numbers, letters, and symbols, like so:

>>> type("3 Musketeers")
<class 'str'>
>>> type('First Order')
<class 'str'>
>>>

As you can see, it tells us the type of the value "3 Musketeers" is str (short for string).

Sometimes, you may have a string with an integer inside it or an integer that you want to put in a string. The first scenario often happens with user input where everything is returned inside a string. To be able to use it, we need to convert it to the desired data type.

Python allows you to convert string type values to integer type values and vice versa. Using the built-in str function, you can convert an integer to a string:

>>> str(7)
'7'
>>>

Strings can also be converted to integers, as long as they hold a valid integer value within. This is done by use of the built-in int function:

>>> int("100")
100
>>>

An error occurs if we try converting a string that doesn't contain an integer. Here, the string "Foobar" can't be converted because it's a string of letters. "3.14159" also fails because it is a float, and not an integer:

>>> int("Foobar")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'Foobar'
>>> int("3.14159")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '3.14159'
>>>

These are the basic types of values we'll be dealing with in this chapter.

In this exercise, we will learn how to assign a value to a variable:

This means that the reference number is removed and no longer points to the value 7. When we try printing out the now nonexistent variable, we get an error stating that the name number is not defined.

We use variables when we have a value in our code that we want to use multiple times. They prevent us from having to repeat that value each time we want to use it, as variables store the values in memory.

When we store values in memory, we can reuse them as many times as we'd like:

Here, we can see the application of a new operation to strings: +. We use this whenever we want to concatenate (add together) two strings.

This only applies to strings, and thus trying to concatenate a string with any other data type will raise an error. We shall look at it in greater depth in the next chapter.

An interesting phenomenon with Python variables is that they are not deeply linked:

>>> x = 1
>>> y = x
>>> x = 2
>>> print(x)
2
>>> print(y)
1
>>>

A behavior you'd expect would be that y being assigned to x would change upon changing x, but it doesn't and stays the same. What do you think is happening?

Since Python variables point to values in memory, when y is assigned to x, it does not make an alias for x but instead points the variable y to where the value of x, 1, is. Changing x changes its pointer from 1 to 2, but y remains pointing to its initial value:

Figure 1.7: Variable assignment

In Python, you can also assign multiple variables in one statement, like so:

>>> a, b, c = 1, 2, 3
>>> print(a)
1
>>> print(b)
2
>>> print(c)
3
>>>

The assignment works so that the first variable, a, is assigned the first value, 1, after the = sign. The second variable, b, is assigned the second value, 2, and the third variable, c, is assigned the third value, 3.

What happens if we try to assign more variables than we pass values?

Python 3.6.0 (default, Dec 24 2016, 08:01:42)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> a, b, c = 1, 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 3, got 2)
>>>

The Python interpreter raises an error and tells us it didn't get enough values to assign to the variables we declared in our statement.

A similar error is raised when we try to assign more values than there are variables:

>>> a, b = 1, 2, 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
>>>

Write a script that will use distance in kilometers and time in hours to calculate and print out speed in kilometers per hour, miles per hour, and meters per second.

Here are some hints:

The steps are as follows:

The output should look like this:

Figure 1.8: Output of running the calculate_speed.py script

So far, we've learned how variables are used in Python and a few of the different values you can assign to them. We've also learned how to use variables in our programs. In the next section, we will be looking at the rules for naming variables.

Python, like other languages, has a couple of rules on naming identifiers such as variable names, class names, function names, module names, and other objects. Some are strictly enforced by the interpreter, while others are simply by convention, and developers are at liberty to ignore them. The rules and conventions are designed to avoid confusion when the interpreter is parsing through code or to make the code more easily readable by humans.

We'll start off by going through some of the rules for naming variables and other identifiers:

The following are examples of valid variable definitions:

>>> meaning_of_life = 42
>>> COUNTRY = "Wakanda"
>>> Ω = 38.12
>>> myDiv = "<div></div>"
>>> letter6 = "f"
>>>

It should also be noted that Python identifier names are case sensitive. Consider this:

>>> foobar = 5

This is a different variable from the following one:

>>> Foobar = 5

Certain names in Python cannot be used as they are parts of the language syntax. Such words are known as reserved words or keywords. An example of a reserved word is import, which is a statement used for when you want to import a module into your code.

Python has several keywords. To get the full list, perform the following steps:

You should not use any word from this list of keywords as an identifier name. Note that you don't have to remember them all as the Python interpreter will restrict you from using them.

In the following example, we are trying to use the keyword for, but we get a syntax error upon doing so. The same applies for all keywords:

>>> for = "Elise"
  File "<stdin>", line 1
    for = "Elise"
        ^
SyntaxError: invalid syntax
>>>

Python has several guidelines for naming identifiers that aren't enforced by the interpreter. These guidelines are meant for consistent code and making it more readable. Please note that these are simply guidelines and the programmer is at liberty to ignore them.

It should be counterpointed that ignoring naming conventions eventually leads to a road of regret as they provide several advantages, such as the following:

Some of these conventions and guidelines are given here.

Compound variable names should be written in snake_case notation.

Prefer this:

>>> first_letter = "a"

Over this:

>>> firstLetter = "a"  # camelCase
>>> FirstLetter = "a"  # PascalCase

Naming for constants should be written in capital letters to denote that their values are not meant to change. In reality, though, Python has no way of restricting the value of a constant from being changed as they are variables, just like any other:

>>> NUMBER_OF_PLANETS = 8
>>> RADIUS_OF_THE_EARTH_IN_KM = 6371

Note that we can change a constant's value:

>>> NUMBER_OF_PLANETS = 9
>>>

Avoid lower case l or uppercase O as single character variable names, as in some fonts, these letters can be mistaken for 1 and 0, respectively, making the code harder to read.

In the next section, we'll learn about comments, their importance, and how to write them in Python.

Write a script that will calculate the area and circumference of a circle with a radius of 7. In this activity, we'll get better acquainted with variable assignment as well as variable naming conventions.

Here are some hints:

The steps are as follows:

The output should look like this:

Figure 1.9: Output of running the circle.py script