2.1 Variables

Computer programs are usually required to store information in some way for later retrieval or manipulation. In the Stroop Task program we saw in chapter 1, for each trial, we need to store the color and the word that our computer picked. In addition, we want to record the reaction time of the subject. Otherwise, the Stroop Task program would be utterly useless for examining the relation between reaction times and (in)congruence between words and their colors. In other words, the Stroop task program would be useless if it could only manipulate values as we did when we calculated 2 + 2. You see, when your computer performs a simple value manipulation you get a momentarily answer. At times, computers are too efficient for their own good. They quickly forget about the values that pass through their system. The very moment they finish a calculation, computer programs forget the outcome of a calculation. They even forget that they ever performed the calculation (if you do not remind them that they indeed did). This is where variables come in handy. Variables are storage units in a computer’s memory. A variable can store any kind of value. Unlike the result of simple value manipulations, such as 2 + 2, variables have designated storage addresses in a computer’s memory. You need a way to access variables in your computer’s memory and hence, you give them a name. You can think of a variable’s name as a unique identification address in the computer’s memory. In fact, during a value assignment, a value is stored at a certain position in the computer’s memory. This position as a precisely defined location, much like longitude and latitude coordinates describe a physical location in the Global Positioning System (GPS). The command by which a value is stored in a variable is called an assignment statement. It is common to say “a value is assigned to a variable”.

a = 4
b = "This is a string"

print(a)

## 4

print(b)

## This is a string

The order in which the variable and a value are placed around the equal sign = is not arbitrary. Variables always have to be on the left side, values on the right side. Everything else will produce an error. As mentioned above, variables can store any kind of value. The right side can be a complex expression, which is not obviously a value at first sight.

a = 13*17/23
print(a)

## 9.608695652173912

The single equal sign, as in a = 4 is exclusivey reserved for assignment statements. If you read a program out loud, practice saying

a is assigned the value 4

A double equal expression, as in a == 4 is used for comparing two values, as in “Does the value of ‘a’ equal 4?” That is completely different to an assignment and will be covered in Section 2.3 Data types and in more detail, in Chapter 3.

Programmers have much freedom in naming variables, but some strict rules exist, as well as some conventions. Some of them are good practice and others will throw syntax errors if not adhered to. In the beginning, you may think of good practice guidelines as superfluous, but you will learn to value them once you start making more complex programs.

Heeding them pays off!

1. Programmers give meaningful names to variables in order to make their code more readable for others and themselves. Without meaningful names, they easily get lost when reading through their code again. Even to them their own code may appear as nothing more than gargle-bargle.

2. The first character of a variable must be a letter of the alphabet, either uppercase or lowercase ASCII or Unicode, or an underscore.

3. The rest of a variable name may consist of letters (uppercase or lowercase ASCII or Unicode characters), underscores, or digits (0-9).

4. Variable names are case-sensitive. This means that the variables myString and mystring are not treated as the same variable by your computer.

5. You may still get sytnax errors despite adhering to all rules named above. Chances are high that you tried to use one of Python’s keywords as a variable name. Python uses a number of keywords to recognize the structure of a program.if and for are keywords for example. Your Python interpreter can tell you the complete list of keywords known to your Python version:

import keyword
print(keyword.kwlist)

## ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

2.2 Use of variables in the Stroop Task

Now that you read about how variables are assigned their values, let’s have a look at how variables are used in the interactive Stroop program.

# a list for gathering the response times
RT = []

# remember when stimulus was presented
time_when_presented = time()

# remember when the user has reacted
time_when_reacted = time()

# calculate the response time
this_reaction_time = time_when_reacted - time_when_presented
RT.append(this_reaction_time)

In the first line of the above code snippets from the Stroop Task program, an empty list is assigned to the variable RT. The purpose of this list is to store reaction times during the Stroop experiment. You will learn more about lists in Chapter 4. For now it suffices to know that lists are yet another data type, capable of containing values of multiple data types at the same time! You may reckon that they are the ultimate structure for storing information. The variables time_when_presented and time_when_reacted respectively store the point in time (using the function time) at a certain event. time_when_presented records the moment in time when a stimulus is presented and time_when_reacted saves the moment in time when the subject reacts to the stimulus. The reaction time of the subject is then calculated by subtracting one stored point in time from the other and saved in the variable this_reaction_time. Finally, the subject’s reaction time is appended to RT, meaning that this_reaction_time is saved in RT before the program proceeds to the next trial. A disclaimer; the code snippets above obviously reduce the mechanics of the Stroop Task program to some highlighted variable assignments. This means that the code lacks the actual dynamics of the program and will not run as is. But it captures the basic idea of how the program records and manipulates a participant’s reaction time with the help of variables.

2.3 How Variables Are Used

Variables are an essential component of all programs, with numerous applications. This section provides but a glimpse into the vast and creative possibilities of variables. Do not worry, you will soon get a hang of it once you start doing some programming yourself. One common way of using variables is storing the output of functions:

import random
a = random.randint(0,10)
print(a)

## 2

You will learn in detail about functions in Chapter 6. For now it is good enough to know that the function random.randint(0,10) randomly picks an integer between 0 and 10, and returns the chosen integer. Whatever number is picked by the function is stored in the variable number and can easily be retrieved and used for other purposes elsewhere. If this piece of information does not satisfy you, simply type help(random) after importing random and your interpreter will give you a more detailed description of the class random.

A variable’s assigned value can be updated. This means that its value can be changed after an initial assignment. This is very useful for structuring a program:

# determining the maximum number of trials
n_trials = 3
# setting a counting variable to 0
# at the beginning of the program
n = 0
# adding 1 to n as long as n does not exceed n_trials
while(n < n_trials):
    # do something
    n = n + 1

This comes in handy if you want to repeat a part of your program until a certain condition is fulfilled. For instance, imagine taking measurements for a fixed number of trials for a psychological experiment. In the example above, n_trials and n are used for creating a counting mechanism until the desired number of repeated measurements is reached. Note how the old value of n is used to update the value of n after one execution cycle of the program in n = n + 1. After the first execution of the while part of the code snippet,n will have the value 1 instead of 0! If you are not yet fully getting the hang of it, do not worry. You will learn more about the use of conditionals and the while loop in Chapter 3 and Chapter 5, respectively. The basic idea behind the above code snippet is to show you how updating variables can be used to create a counting mechanism in a computer program.

2.4 Data types

Earlier in this chapter, you learned that each value belongs to a certain class or data type. This section will introduce the basic data types: integers, floats, strings, and booleans. Apart from the basic data types, Python knows numerous specialized types. Earlier in this chapter, you already encountered two such specialized data types: dictionaries and lists. Literally any computer program contains values of at least the basic types and thus, it seems to be reasonable to say a word or two about them.

number = 7
print(type(number))

## <class 'int'>

number = number + 3.5
print(type(number))

## <class 'float'>

number = 10.5
int(number)

## 10

10

## 10

print(type("17"))

## <class 'str'>

print(type("13.65"))

## <class 'str'>

quote = "Freud: "The mind is like an iceberg, it floats with one-seventh of its bulk above water.""

## [1] " Error: invalid syntax (<string>, line 1)"

quote = 'Carl Rogers: "How can I provide a relationship which this person may use for his own personal growth?"'

quote = "Ivan Pavlov's best known findings relate to the phenomenon of conditioning."

print(5 == (3+2))

## True

print(5 == 6)

## False

j = "hel"
print("hello" == j + "lo")

## True

print(type(True))

## <class 'bool'>

print(type(False))

## <class 'bool'>

number_of_EC_required_for_BSA = 45
passed_BSA = number_of_EC_required_for_BSA <= 50
print(passed_BSA)

## True

2.5 Object variables in a Yeti

In the Stroop program, variables are use to collect the response times, one simple number at a time. This data is collected for the purpose of subsequent data analysis. That means (or even implies) this data remains unprocessed.

The situation in a Yeti is different in two ways:

1. Video frames are more complex than numbers ??. They are a grid of numbers, i.e. they are compound.
2. The whole point of a Yeti is to deeply process the incoming video data.

In Python, compound variables are usually referred to as objects and programming with objects is called object-orientation (OO). The creation of objects in a program looks similar to storing the result of a function in a variable. The following line from Yeti2 reads a frame from the video device and assigns it to the variable Frame. A function that creates an object in such a way is called a constructor.

Frame = video_capture.read()

In the Stroop program, most variables are created once and remain unchanged. The only variables that change are concerned with the measurement of response times and the STATE variable, which keeps track of the program flow. If you see a program as a machine that takes data as input and produces data as output, the Stroop task converts a letter to a float number every two (or so) seconds. Because interactive programs have the human wetware in the loop, they are usually sluggish. The biggest problem is the motor system. A world-class typist can hit the keyboard with a rate of 13 strokes per second. In the ASCII scheme, one letter is worth 1 Byte (8 Bit). The maximum data input rate of any keyboard-driven program is 13 Bytes/second.

A Yeti is a program that operates on an input stream of YET, which according to the next program is many magnitudes larger.

width    = 640
height   = 480
subpixel = 3
fps      = 30 # frames per second
input_rate = width * height * subpixel * fps

print("Yeti input data stream: " + str(input_rate) + " Bytes/second")

## Yeti input data stream: 27648000 Bytes/second

A Yeti has to do some serious number crunching to get from the raw video frame to the measures for eyeball position. The following code block shows the data processing chain of Yeti2, which uses changes in brightness distribution to locate the eye ball.

center_ratio = .85
threshold = .05
(x, y, w, h) = eye
F_eye = cv2.resize(Frame[y:y+h,x:x+w], dim,interpolation = cv2.INTER_AREA)
F_left = F_eye[0:height, 0:int(width/2)]
F_right = F_eye[0:height, int(width/2):width]
bright_left = np.sum(F_left)
bright_right = np.sum(F_right)
bright_dist = bright_left/bright_right

The many assignment operators are typical for data processing chains. In this particular algorithm, the incoming data is split in a left and a right frame, which undergo a brightness analysis separately, before they are merged into a single number for brightness distribution.

What is remarkable about this chain is that it starts with a whole lot of data (one YET frame per 18ms), but it ends with a single floating point number. This is called a data reduction mechanism. Most, if not all, techniques in Statistics and Machine Learning are data reduction mechanisms.

The purpose of Yeti2 is to reduce data, but the user interface of the program is a video stream equal to the input. Even more, the output video stream is an improved version of the original by being

• enhanced by focusing on the eye
• interactive, as the program reacts to voluntary eye movements
• augmented, as the real view is enhanced by processed data

Let’s take a look at how the user interface of Yeti2 is assembled:

F_out = cv2.putText(F_eye, f"{bright_dist}", (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (255,0,0))
F_out = cv2.putText(F_out, f"{Position}", (200, 200), cv2.FONT_HERSHEY_SIMPLEX, 2,
        font_col, thickness = 8)

Again, we see a chain of assignment operators. Function cv2.putText takes the frame capturing the eye F_eye as input and produces as output the same frame with a text overlay for brightness distribution (F_out). The same function is applied to F_out, this time adding the guessed position and the result is written back to the same variable name. That is called updating a variable and it reduces the memory consumption of the program. For a tedious task as putting together an augmented display one text box at a time, updating avoids the problem of finding a unique name for every step.

2.6 Common errors

1. Confusing the assignment operator (=) with the comparative equals operator (==). The first is solely used for assigning values to variables as in

myString = "This is an assignment statement"

the latter for comparing two values

17+3 == 21

## False

Usually, when you confuse the assignment operator with the equals operator, you will get a syntax error.

17+3 = 21

## [1] "Error: can't assign to operator (<string>, line 1)"

2. Forgetting to typecast other data types when incorporating them into strings

myGrade = 8
print("I got an " + myGrade + " on the last exam!")

## Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: must be str, not int
## 
## Detailed traceback:
##   File "<string>", line 1, in <module>

Often, you will want to export some arithmetic result (such as a participant’s reaction time in the Stroop Task program) or other non-string data out of the program, or you simply want to print them to the screen. This is usually done by first converting the data into type string and then writing to some external file (such as good old plain text files) or using the print command to write to the console. Quite often people forget that explicit typecasting is required when incorporating non-string values into a sequence of strings.

myGrade = 8
print("I got an " + str(myGrade) + " on the last exam!")

## I got an 8 on the last exam!

3. Unintentionally cutting off decimals when typecasting to integers.

import numpy
RT = [3.749,2.998,3.0147]
mean_RT = numpy.mean(RT)
print("The subject had a mean reaction time of " + str(int(mean_RT)) + " seconds.")

## The subject had a mean reaction time of 3 seconds.

Obviously, a mean reaction time of exactly 3 is unrealistic with 3.749, 2.998, and 3.0147 as individual trial reaction times. You may feel inclined to typecast anyway to shorten the numerical string expression, but remember that typecasting from float to integer results in the loss of any information after the decimal point. Besides, usually there are better ways for rounding off floating points; consider the round method for instance.

import numpy
RT = [3.749,2.998,3.0147]
mean_RT = numpy.mean(RT)
print("The subject had a mean reaction time of " + str(round(mean_RT, 3)) + " seconds.")

## The subject had a mean reaction time of 3.254 seconds.

4. Forgetting to reassign an updated value of a variable

count = 1
count + 1

## 2

print(count)

## 1

Remember to assign the new value of a mutated variable to either a new variable or the original variable name; your computer will otherwise ignore the variable mutation and keep the variable’s old value in memory.

count = 1
count = count + 1
print(count)

## 2

2.7 Debugging

Despite all efforts and skill, programmers encounter programming errors on a daily (if not hourly) basis. In this, programming beginners and experts are no different. In fact, debugging is a very challenging and instructive task in itself.

Apart from some general good debugging practices introduced in chapter 9 Debugging, there are some tricks that are especially useful in tracing errors that originate from the variables in your program.

1. Checking all of your equals == and assignment = operators is a good start when tracking down bugs suspected to originate from variables. For this you can either scan your code from top to bottom manually or use the search function of your programming environment. Use Cltr + F to search for an expression in your code (in this case either = or ==, or the name of the variable you expect to be the culprit). Then, for each instance of the equals == or = assignment operator, or the variable itself, ask yourself whether you used the right operator for the intended job. Confusing the equals and assignment operator usually results in a syntax error, but a syntax error does not necessarily need to originate from confusing operators. In fact, syntax errors are undoubtly the most generic errors in programming.

2. Once you are positive that the bug is not caused by confusing the equals with the assignment operator, you should take a closer look at the operations you perform on your variables (such as comparing variables or performing arithmetic calculations). Operations are another potential source of bugs.

a = 1
b = "1"

print(a + b)

In the example above, it is evident what goes wrong. Strings and integers cannot be added as two numbers are summed. A type error is thrown. However, in more complex programs it is often less evident where the bug originates from. Therefore, it is useful to check the data type of your variables at multiple locations in your program. Who knows, you may have unknowingly converted a variable to another type somewhere in your code and at a later moment, this causes your program to throw an error. Use the functions type() and print() to display the data type of your variables at different places in your code and hit run!

a = 1
b = "1"

print(type(a))

## <class 'int'>

print(type(b))

## <class 'str'>

3. Performing operations on variables may still have unexpected results, even when no type errors are involved. Arithmetic (+, -, *, /) and Boolean operators follow rules of precedence. Arithmetic operators follow the same rules of precedence as you learned about in highschool mathematics. All arithmetic operators also precede any Boolean operator, meaning that in the code snippet below 1 + 1 is evaluated before being compared to 2.

print(1 + 1 == 2)

## True

As a debugging strategy, it is useful to change the precedence of operators with the help of brackets (). The bug may originate in a false assumption about operator precedences. Using brackets, you can make sure that operations are executed in the exact order you intended.

4. When you neither confused the equals with the assignment operator, nor made a type error, nor had false assumptions about operator precedences, the last resort is to mentally follow the flow of your program and to check whether your variables are assigned the expected value at all times. For instance, in the code snippet below, you may expect the result to be 1 since you added 2 to the initial value of a and 2 / 2 is 1.

a = 0
b = 2

a + 2

## 2

print(a / b)

## 0.0

However, a was never assigned the new value of 2 and 0 / 2 is obviously 0. It is easy to overlook such a mistake when scanning through your code. Therefore, checking which values are assigned to your variables as you read through your program is very helpful. You could for instance adjust the code above if you are puzzled why the result is not 2, like so

a = 0
b = 2

a + 2

## 2

print(a, b, a / b)

## 0 2 0.0

which prints first the value of a, then b and then the result of a / b to the console.

2.8 Exercises

x = 2
y = 1.0
print(x + y)

x = 4.0
y = x + 1
print(x + y)

x = 1
y = "1.0"
print(x + y)

x = 4
y = 4.0
print(x == y)

x = 12
y = x / 2
print(y >= 5)

x = "1.0"
y = "1"
print(x + y)

x = 5
y = 2
print((x / y) == 2.5)

x = 1
x = x + 1
x = x - 2
print(x)

x = 1
2x = 2
print(x + 2x)

x = 3
y = "3"
print(x = y)

name = "Colin"
print(This is + name)

myString = "The statement 'Veni, vidi, vici.'"
s1 = " was coined by Gaius Julius Caesar."
myString = myString + s1
print(myString)


myString = "The statement 'Veni, vidi, vici.'"
s1 = " was coined by Gaius Julius Caesar."
s2 = ", 'I came, I saw, I conquered.',"
myString = myString + s2 + s1
print(myString)


myString = "The statement 'Veni, vidi, vici.'"
s1 = " was coined by Gaius Julius Caesar,"
s2 = " supposedly around "
year = 47
s3 = " BC."
myString = myString + s1 + s2 + year + s3
print(myString)

Reg       = "What have the Romans ever given us?"
man1      = "The aqueduct?"
2ndMan    = "The sanitation"
m@n3      = "And the roads"
man_4     = "Irrigation"
man 5     = "Medicine"
SixthMan  = "Education"
man_no._7 = "And the wine!"
8thMan    = "Public votes"
no9atReg  = "Public order; it's finally safe to walk in the streets at night."
reg       = """All right. But apart from sanitation,
            medicine, education, wine, public order,
            irrigation, roads, a fresh water system,
            and public health;
            what have the Romans ever done for us?"""

participants = 52.0
trials = "200"
experimental_sessions = 3
trials_pp = trials * experimental_sessions
conditions = 4


# to be implemented by you
condition1 = 
condition2 = 
condition3 = 
condition4 =

print("In total,", participants, "participants participated in the study.")
print("A 2x2 factorial between-subjects design was employed.")
print("The study examined the interaction of two independent variables: ")
print("task difficulty (easy, difficult) and time (limited, unlimited).")
print(conditions, "conditions were devised, plus a control condition.")
print("The conditions were:",condition1,condition2,condition3,condition4)
print("Participants were tested in", experimental_sessions, "experimental sessions.")
print("Each session consisted of",trials,"trials.")
print("In total, each partcipant thus completed", trials_pp, "trials.")

n1 = 238
n2 = 17

print(n1 ? n2)
print(n1 / ? == 14)
print(n1 * ? == n2)
print(n1 + ? == n2 - ? and n1 + ? == 972%243 and n2 - ? == 0)
print(n2 * ? == n1*47)
print(n1 / ? == n2 / ? * ?)

2.9 Think Further

1. For more information and exercise on Variables and Data Types you may want to consult some of the following resources:

   • Downey, A. (2012). Think Python. O’Reilly Media, Inc.. Chapter 2. Variables, expressions and statements
   • Official Python Tutorial, parts 3.1.1 Numbers and 3.1.2 Strings
   • Learnpython ``Variables and Types’’ interactive tutorial
   • Swaroop, C. H. (2003). A Byte of Python. Chapter 6 ``Basics’’

2. Are statistical techniques data reduction mechanism, in that they take in a lot of data and reduce it to a few numbers? Take three statistical techniques from the top of your head and make the check.

3. Think about your own brain. Does it use any data reduction mechanisms?