*This notebook contains an excerpt from the Python Programming and Numerical Methods - A Guide for Engineers and Scientists, the content is also available at Berkeley Python Numerical Methods.*

*The copyright of the book belongs to Elsevier. We also have this interactive book online for a better learning experience. The code is released under the MIT license. If you find this content useful, please consider supporting the work on Elsevier or Amazon!*

< 2.0 Variables and Basic Data Structures | Contents | 2.2 Data Structure - Strings >

# Variables and Assignment¶

When programming, it is useful to be able to store information in variables. A **variable** is a string of characters and numbers associated with a piece of information. The **assignment operator**, denoted by the “=” symbol, is the operator that is used to assign values to variables in Python. The line `x=1`

takes the known value, 1, and **assigns** that value to the variable with name “x”. After executing this line, this number will be stored into this variable. Until the value is changed or the variable deleted, the character x behaves like the value 1.

```
x = 1
x
```

```
1
```

**TRY IT!** Assign the value 2 to the variable y. Multiply y by 3 to show that it behaves like the
value 2.

```
y = 2
y
```

```
2
```

```
y*3
```

```
6
```

A variable is more like a container to store the data in the computer’s memory, the name of the variable tells the computer where to find this value in the memory. For now, it is sufficient to know that the notebook has its own memory space to store all the variables in the notebook. As a result of the previous example, you will see the variable “x” and “y” in the memory. You can view a list of all the variables in the notebook using the magic command `%whos`

.

**TRY IT!** List all the variables in this notebook

```
%whos
```

```
Variable Type Data/Info
----------------------------
x int 1
y int 2
```

Note that the equal sign in programming is *not* the same as a truth statement in mathematics. In math, the statement *x = 2* declares the universal truth within the given framework, *x is 2*. In programming, the statement `x=2`

means a known value is being associated with a variable name, *store* 2 in x. Although it is perfectly valid to say *1 = x* in mathematics, assignments in Python always go *left*: meaning the value to the right of the equal sign is assigned to the variable on the left of the equal sign. Therefore, *1=x* will generate an error in Python. The assignment operator is always last in the order of operations relative to mathematical, logical, and comparison operators.

**TRY IT!** The mathematical statement x=x+1 has no solution for any value of *x*. In programming, if we initialize the value of *x* to be 1, then the statement makes perfect sense. It means, “Add x and 1, which is 2, then assign that value to the variable x”. Note that this operation overwrites the previous value stored in *x*.

```
x = x + 1
x
```

```
2
```

There are some restrictions on the names variables can take. Variables can only contain alphanumeric characters (letters and numbers) as well as underscores. However, the first character of a variable name must be a letter or underscores. Spaces within a variable name are not permitted, and the variable names are case-sensitive (e.g., *x* and *X* will be considered different variables).

**TIP!** Unlike in pure mathematics, variables in programming almost always represent *something* tangible. It may be the distance between two points in space or the number of rabbits in a population. Therefore, as your code becomes increasingly complicated, it is very important that your variables carry a name that can easily be associated with what they represent. For example, the distance between two points in space is better represented by the variable *dist* than *x*, and the number of rabbits in a population is better represented by *nRabbits* than *y*.

Note that when a variable is assigned, it has no memory of *how* it was assigned. That is, if the value of a variable, * y*, is constructed from other variables, like

*, reassigning the value of*

*x**x*will not change the value of

*y*.

**EXAMPLE:** What value will *y* have after the following lines of code are executed?

```
x = 1
y = x + 1
x = 2
y
```

```
2
```

**WARNING!** You can overwrite variables or functions that have been stored in Python. For example, the command `help = 2`

will store the value 2 in the variable with name *help*. After this assignment *help* will behave like the value 2 instead of the function *help*. Therefore, you should always be careful not to give your variables the same name as built-in functions or values.

**TIP!** Now that you know how to assign variables, it is important that you learn to *never* leave unassigned commands. An **unassigned command** is an operation that has a result, but that result is not assigned to a variable. For example, you should never use *2+2*. You should instead assign it to some variable `x=2+2`

. This allows you to “hold on” to the results of previous commands and will make your interaction with Python must less confusing.

You can clear a variable from the notebook using the *del* function. Typing `del x`

will clear the variable * x* from the workspace. If you want to remove all the variables in the notebook, you can use the magic command

*%reset*.

In mathematics, variables are usually associated with unknown numbers; in programming, variables are associated with a value of a certain type. There are many data types that can be assigned to variables. A **data type** is a classification of the type of information that is being stored in a variable. The basic data types that you will utilize throughout this book are boolean, int, float, string, list, tuple, dictionary, set. A formal description of these data types is given in the following sections.

< 2.0 Variables and Basic Data Structures | Contents | 2.2 Data Structure - Strings >