2.2: Variables Part 2: Variables Take Flight!

By the end of this lesson, you should be able to:

• Create a program that uses and modifies variable values
• Demonstrate how to create a variable in python
• Demonstrate how to look at the value of a variable
• Demonstrate how to change the value of a variable
• List the different mathematical operators that can be used in python
• Describe the Order of Operations and how it is applied when performing math calculations in python.

Steps to Success

1. Making a Change: Dynamic Variables
2. Drone Math: It’s as Easy as 2+2 = 4
3. Going in Circle: Variables Referencing Themselves
4. Challenge 1: A Not-So-Simple Rectangle
5. Challenge 2: Shuttle Run

As we learned earlier, you can also change the value of a variable, even in the middle of a program! Write the program below. Before you launch the program, guess what you think will happen. Now run the program. What did you observe?

import CoDrone_mini

drone = CoDrone_mini.CoDrone()

drone.pair()


duration = 1

drone.takeoff()

drone.hover(duration)

drone.land()

duration = 2

drone.takeoff()

drone.hover(duration)

drone.land()

duration = 3

drone.takeoff()

drone.hover(duration)

drone.land()

Was your guess right? Below is what should have happened.

.

.

.

If you guessed that the drone will hover a second longer each time it takes off, you would be right.

Variables are dynamic, meaning their values can be changed during a program’s execution. However, if we were to enter an actual value, it is called static  or often referred to as hard coded. This means that the value typed into the command cannot change while the program is running:

drone.hover(duration) # duration can change while the program is running
drone.hover(3) # value is hard coded, cannot be changed during program operation

What are some other ways you can think of that using variables and changing them during the program would be useful?

You may have heard this before, but there are a number of common concepts between math and programming. Just like in your math class, you can do math with your variables. These are some of the operations you can use:

• + : addition 
• – : subtraction 
• * : multiplication 
• / : division 
• %: modulo (this is a special one, it does NOT mean percent)
• **: exponent

Let’s open the Python console again and try out some examples:

>>>4+3 # should return 7

>>>2*5 # should return 10

>>> 10/2 # should return 5.0

>>>2**3 # should return 2 to the 3rd power or 8

 

So we know now that Python console can do some simple math calculations for us.  Now we will try a little more complex one. Before you type this in and hit enter, make a guess based on your knowledge of Math, what you think the answer will be. 

>>>10*3+4/2-8

 

What value did you guess? Was it the value you received from Python console? The value you should have received was 24.0.  We know that, in Math, when we are simplifying an equation like this one we use PEMDAS. 

P: Parenthesis

E: Exponents

M: Multiplication

D: Division

A: Addition

S: Subtraction

The Python programming language also follows this rule with a few minor modifications. One such modification is the Modulo (%). What we would typically think of as the percent sign in normal math equations, this symbol in Python programming means to return the remainder from division. So the modulus of 5%2 is 1 (two goes into 5 twice with a remainder of 1. It is often used to find out whether a number is even or not. For example, I can pick any number and two. If the modulus of that number and two is 0, the number is even. Otherwise, the number is odd. Let’s try some examples in the Python console:

>>>10%3 # should return 1

>>>9%3 # should return 0

>>>11%7 # should return 4

>>> 345829%2 #should return 1, so it is an odd number

 

The modulo operator is the result of division, so it has the same precedence as multiplication and division in the PEMDAS order of operations. Now that we know the modulo operator, let’s try one more example. Try to guess what the value will be before hitting enter:

>>>(10%3*2)+4-5*2+2**4

 

The answer you should receive is 12. If you don’t understand, try writing out the steps of the calculation on paper until you are able to get to the correct answer. 

So we know python can do order of operations, but can it also do math on variable values? Let’s try an example in the Python console:

>>>x=4

>>>y=3

>>>print(x*y)

 

The value that is printed should be 12 (3 multiplied by 4). When performing math on variables, Python substitutes the current value of the variable and completes the calculation just as we saw earlier using the order of operations. We can even use the same variables multiple times. Let’s try this example (make sure x and y are still in the variables pane and are set to 4 and 3, respectively):

>>>z=x**y+x-y

>>>print(z)

 

The printed value should be 65. So we can use variables multiple times and use their values to be stored in other variable values. This is just another reason variables are so valuable!

Now that we know we can do math with variables, we can see how to update a variable’s value by using its current value. This might seem a little circular, but it actually works and is very common when repeating and incrementing in loops (which we will learn about in a later lesson). Enter the following in the console:

>>>power = 5 # initialize a variable to 5

>>>print(power)

>>>power = power + 5 # add 5 to power and reassign the value

>>>print(power)

 

The first time power is printed, it gives us the value of 5, the second time it gives us the value of 10. This can be a tricky concept for new programmers to understand, so let’s break down what is actually happening:

The line of code says:

>>>power = power+5

What is actually happening:

When this is used in programs, you will often see it typed in a shorthand format that looks like the following:

>>>power+=5 #this is the same as power = power +5

 

This shorthand is the same as what we calculated earlier. You can also subtract, multiply, and divide in the same way. For example, try the following and see what happens:

>>>x=2

>>>x=x*3

>>>print(x) #should print 6

We have flown in a square, where all sides are the same length, but what about a rectangle? Remember that a rectangle has two sets of sides that are the same length (A square is a special type of rectangle). For this challenge, you will make the drone fly in a rectangle. This may seem easy, but there are some rules that will make it a little more challenging!

Rules:

1. Name your File 3_2_Challenge1
2. You cannot use any hard coded values (except Directions if you are using the go() command)
3. You can only use 3 variables called power, duration, and side
4. You cannot make a square. A set of two parallel sides must be longer than the other 2 sides. 
5. You can only use math operators on variables to get different values (you are not allowed to reassign variable values once they are initialized).

Not Allowed

drone.go(Direction.FORWARD, 2, 20) # Hard coded values of 2 and 20 not allowed

power = 20 # declare and initialize power variables

power=10 # update with hard-coded value later in the program (not allowed)

 

Allowed

drone.go(Direction.FORWARD, duration, power) #Direction values are allowed

drone.go(Direction.FORWARD, duration/2, power) # Can use math operators on variable names

side=side +1 # Variables can be updated with their own value or other variable values

The concept of a shuttle run is to run back and forth while increasing in distance! For this challenge, we will now be doing a shuttle run with our drone! In order to complete this challenge, it is important we set up a few variables, such as power and duration. Use the following code as a foundation for your shuttle run program! Hint: Variables can change!

Rules:

1. Name your File 3_2_Challenge2
2. The drone’s distance must increase each shuttle by the same amount
3. You cannot use hard coded values, you must use variables.

Example Code:

import CoDrone_mini
drone = CoDrone_mini.CoDrone()
drone.pair()
power = 25
duration = 3
drone.takeoff()
drone.set_pitch(power)
drone.move(duration)
# Fill in the rest!