In this lesson we will learn about using variables in our programs.


Introduction to Variables

Imagine we’re making a game in an arcade. The player selects a character and starts playing, winning points until it ends.

How would we keep track of the player’s points within our program? Using a **variable**. A variable is a named value that we can access and change. Variables hold the data within our programs.

Variables are a fundamental part of programming: they enable you to track values by assigning names to them. Once we've made a variable, we can access and change its value throughout our program. 

In this lesson, we will discuss variables, what they are used for, and how to use them.

We've learned how to count up the player's points but what happens if the player wins bonus points at the end of a round. How do we calculate them?

We can use expressions for this. 


###### Expressions

Expressions are programming statements that are evaluated and converted into a value.
The expression below returns a value of 300 by using the ‘+’ operator to add numbers together:

```python
100 + 200
```

Expressions can use variables. The expression below returns the value of the points variable and 100 added together:

```python
points + 100
```

###### Assigning Variables Using Expressions

Now we can assign a new 'bonus points' variable that rewards the player for completing the round quicker:

```python
bonus_points = 10000 / time_taken_seconds
# Set bonus points to 1000 divided by the number of seconds it took to win the level
```

Keep in mind that some numbers are different from others. For example, some numbers are only whole numbers, others can have decimal points.

Most languages are smart enough to store the values after the decimal point when required.  If we were writing a Python program to convert Fahrenheit temperatures to Celsius, we could use two variables:

```python
fahrenheit = 55
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # prints out 12.777777777777779
```

So now we know how to calculate the points in the game using numeric variables.

That helps us write our game but we often need other types of variables in our other programs. We will discuss them next.

Numeric Variables

**String** variables are used to track **sequences** of characters (letters, spaces, numbers, or symbols). 

Let's say we want two variables to hold parts of an a

```python
line1 = "123 Main Street"
city = "New York City"
```

Strings often have the ability to combine with other strings, which is called **concatenation**. Let's combine the parts of our address.

```python
print(line1 + ", " + city)
# Outputs 123 Main Street, New York City 
```

Now we know how to work with strings and numbers, let's move onto variables that can help us with our logic.

String Variables

**Boolean** variables are used to track a true or a false (similar to a ‘yes’ or ‘no’).

Remember our game? We could use a **boolean** variable to track if the game has finished or not.  When the game starts, we could assign the variable to an initial value like this:

```python
game_over = False
```

When the user runs out of lives, the following code could then set this variable to true so that the program knows that the game is over:

```python
game_over = True
```

We have mentioned the **most common** variable **data types**, those that are common to many languages. Now lets review what we have learned so far in this lesson.


Boolean Variables

Now that we've learned what variables are, let's learn to create and use them.

When creating variables, some computer languages require us to declare them, others create them automatically. For example:

- Java requires variables to be declared.
- Python doesn't require variables to be declared.

When we declare a variable, we specify a variable name, additional information like the data type, and sometimes the initial value.

In Java a variable declaration looks like this:

```
int points;
```

In Python, we can create a 'points' variable and **assign** it a value of twenty like this:

```python
points = 20
```

As the game is played and the user wins points, we can update the points, **reassigning** the variable's value:

```python
points = points + 100
```

And if we want to print out the points at the end of the game, we can **retrieve** the variable's value using its name:

```python
print(points)
# Outputs 120
```

This is perfect for counting and printing the points. However, variables are often used to store the values of complex calculations and in the next exercise we will learn about using expressions for calculations!






Assigning & Retrieving Values

Variables are one of the most important aspects of learning to program. Throughout this lesson we've covered:

- Assigning & Retrieving Values
- Performing Calculations Using Expressions
- Different Variable Types for Data Types (numeric, string & boolean)


Let's review:

**Variables** can be used to track values in a program.

### Numeric Variables

We explained that values can be assigned to and retrieved from a variable by using the variable name. 

```python
points = 0 
print(points)
```

### Expressions

We introduced how expressions can be used to assign calculated values to variables:

```python
high_score = points + 100
``` 

### Data Types

We explained that your program will have to work with many kinds of data and it is useful to be able to have variables with different types. We introduced some common data types:

- Numbers
- Strings
- Booleans

Well done! You have learned one of the fundamental concepts of programming! 

