Python Variables

Variables are an integral part of computer programming. They allow us to save results of operations and calculations temporarily in memory and then reuse the results later on.

In this chapter we shall see, in detail, how variables work in Python; some of the most common errors that occur while constructing variables; and naming conventions to name variables in valid, yet meaningful ways.

As we've seen in the last chapter on Python Basics, creating a variable in Python is as simple as deciding a name, and then typing it followed by an = equals sign followed by the value to be placed in the variable.

Unlike languages such as JavaScript, Java, C++, there is no special keyword to create a variable in Python. For example, in JavaScript we would write var x = 10 to create a variable x with the value 10. Notice the keyword var here — it's used to declare a variable in JavaScript.

Let's quickly create two variables x and y and assign to them the values 7 and 3 respectively:

x = 7
y = 3

These variables can be used just like we would normally use numbers, as is, in arithemtic operations. Consider the following snippet:

If you have the experience of working with another programming language such as Java, C++, then you would know that these languages have two stages of creating a variable.

The first stage is called variable declaration. In this stage the interpreter allocates some space in memory to hold the variable.

For example, consider the following Java code to create an integer variable x:

int x

The int keyword instructs the compiler to allocate some space in memory for an integer (usually 32 bits) and reserve that for x.

The second stage, which is optional, is called variable assignment. In this stage the interpreter/compiler puts a value inside the memory location reserved for that variable.

Here's how variable assignment would look in our previous Java code:

int x = 10

The part x = 10 assigns a value to the location reserved for the variable x.

Now as we just read in the section above, Python doesn't work this way:

As the term 'variable' suggests, a variable can vary in the course of a program.

Let's say we have a variable x with the value 10, as shown below. We can perform a couple of operations using this variable and then later on change it to some other value.

Consider the following code:

x = 10
print(x + 12) # 22

x = 30
print(x + 12) # 42

First we set x to 10, and then print its sum with the number 12. Next we change the value stored in x to 30, and perform the same print routine as we did before.

See how we changed the value of x from 12 to 30. This is what variables are — containers of data that can change during the course of a program.

Better yet, we can even change the type of value stored in a variable in Python. This feature, not available in many programming languages, is known as loose typing.

Consider the following code:

x = 10
print(x + 12) # 22

x = "Hello"
print(x + " World!") # "Hello World!"

To start with, x is an integer. However, later on it becomes a string. The type of x has definitely changed.

In the section below we understand in detail what exactly does it mean to be loosely typed and how is this feature powered in languages such as Python.

In strictly-typed languages such as Java, C++, before we create a variable, we have to specify its type.

During the course of the program's execution the variable's value can surely change — otherwise it wouldn't have been called a variable! However, its type can't change.

So for instance, if you stated that a variable x is an integer, then you can only assign integers to it, not any other data type.

Below shown is a snippet from a Java program:

int x = 10;
x = 'Hello World';

Line 2 here would throw an error since it's trying to put a string into the variable x which is meant to be an integer.

Python, as we know, isn't one of these languages. Rather it's a loosely-typed language.

You can put any value in a variable and then later on change it to any other value of any other data type — no restrictions at all.

But how do these languages give such freedom to the developer? Why don't they need to be given specific commands a s to what type a variable needs to be?

Well, loosely-typed languages automatically perform all the necessary optimisations and type conversions in the background for you.

So when you create a variable x assigned to an integer 10, Python automatically detects that you want an integer to be stored and hence allocates the desired amount of memory for it.

This constant check running in the background is one of the reasons why loosely-typed languages are comparatively a little bit slower as compared to strictly-typed languages. However, for everyday applications the difference is almost negligible!

Anyways, let's come back to Python and see loose typing in action:

x = 10
x = 'Hello World!'
x = True

First we assign an integer to x, then a string and finally a Boolean.

A Boolean might be something new for you — it's simply a true or false value used in conditional execution. Details to come in a chapter upstream.

Naming variables effectively is a fruitful skill developers must have. Variables are imperative to programming and so is naming to variables.

In this section we'll see some rules defining how to and how not to construct variable names, in addition to some common conventions used out there for naming variables.

First let's see some rules.

A variable's name in Python (and in almost all programming languages) can contain only the characters a-z, A-Z, 0-9 and _. Nothing else is allowed!

So for instance, all the following variable names are invalid i.e. they would throw a syntax error.

welcome-message
x1!
main container
raining?

A syntax error is an error arising from the way we've written our code. It is evaluated at compile time, that is during the phase when our program is being understood by the interpreter/compiler.

Coming back to variable naming rules, even digits are only allowed if they do not appear at the start of the variable's name.

For instance, m1 is a valid name, whereas 1m isn't, since 1 appears at the start of the name.

1m

Python has a large list of special keywords reserved for special purposes, as shown below:

Using these words, as is, for variables isn't allowed because it would otherwise interfere with the functionalities prescribed for them in Python.

In the code blow, we attempt to create a variable pass to hold a password, however the code throws an error since pass is a reserved keyword.

pass = "15645"

In short,

Moving on, let's now discuss some common conventions and disciplines of constructing variable names.

Suppose that you have to store a user's name in a variable. It would be really bad if you name the variable a or n or x.

The name a doesn't tell much about what's stored in the variable. A much better name could be username, uname or even just name.

But hold on to your descriptive naming skills — you don't want never-ending names.

Suppose we want to create a variable that stores the first name of a user. Being exceptionally descriptive, we could name it thefirstnameofuser, although this would be more than the required amount of description.

We have to remain in between the scale of description — not too little, and not too much.

Sometimes it's really helpful to abbreviate long words in a variable's name given that the abbreviation seems sensible.

For example, the variable name fname could go well for the first name of a user, instead of firstname. Here we've abbreviated 'first' to 'f'. Similarly, a variable to store the name of a database can be called dbname instead of databasename

But keep in mind that abbreviations don't always work well.

For instance, naming a variable that holds the name of an object's property as pname, instead of propertyname would be a complete mess. pname could mean 'property name' or 'panel name' or 'previous name'. A much better name would be propname — with the word 'property' abbreviated down to 'prop'.

When a variable's name contains more than one word, it's desirable to put a separator between the words to be able to distinguish between them easily while reading the variable, by using some sort of casing convention.

Let's say you have a variable questionsasked that holds the number of questions asked in a quiz program. Seeing this name doesn't right away tell us about the individual words in it. We have to gaze at it for a while until we realize that it says 'questions asked'.

Worse yet, in some words the name could even be misinterpreted by the reader. For example, what can you read in searchinglobal?

Did u read it as 'searching lobal'? Well, that's not what the variable meant. Rather, it meant to say 'search in global'.

The solution to all this is to use a casing convention.

Some common casing conventions are as follows:

1. camelCasing: every word's first letter is uppercased except for that of the first word. Camel casing is the casing used in JavaScript. Here are some identifier names from JavaScript: indexOf, getElementById, querySelectorAll.
2. PascalCasing: every word's first character is uppercased. C# uses pascal casing. Some identifier names from C# are as follows: WriteLine, Readline, GetType.
3. snake_casing: every word is lowercased and separated from the other using an _ underscore character. PHP uses snake casing. Some identifier names from PHP are as follows: array_push, mysqli_connect, str_split.

Coming back to our example, the variable questionsasked could be renamed to one of the following:

1. questionsAsked
2. QuestionsAsked
3. questions_asked

Now it doesn't require much effort on our side to comprehend what exactly is the name of the variable trying to say. All the individual words are recognisable at the first glance.

But which one of these should we use?

To boil it all down, naming isn't something that has a preset list of rules that one could use to devise meaningful names.

Surely there are naming conventions out there, but the best name for a given scenario comes with:

1. Experience — the more you code, the better you become at naming.
2. Lots of trial and error — keep on altering the name of the variable unless and until you think it communicates its purpose in the best way.

Let's say you create a variable name, save a string value in it and then print Name.

name = 'Hello World!'
print(Name)

What you will get as output is not the string stored inside name, but rather an error.

Why?

This is because the interpreter detects that there is no variable named Name and so raises a NameError exception.

The variable that you created was name, however the one you attempted to print was Name. There is a difference in the casing of both these names and likewise they are considered two different entities.

That is, two variables with differently-cased characters are not tantamount to each other.

In the example above, name with every character in lowercase was the variable we created. However, Name with a captial N in the beginning was the one we printed, which isn't the same as name, and thereby doesn't exist in memory.

Referring to a non-existent variable raises a NameError in Python. Always take care of errors of this type.

In this chapter we saw a great amount of detail on variables in Python. From this point onwards our journey of exploration gets into level 2 now that we have almost half of our foundation on Python covered.