Exam Revision Flashcards
What will this code give you?
%cd /
%pwd
%ls
%ls - lt
- (3)
%pwd = given /
%ls - lists all contents of current working directory (from bin@ to cuda-keyring)
%ls-lt (output starting from total 100) - lists all contents of current working directory by working out file size and sorts them by date
What does the ‘%history’ command do in Colab notebooks?
The ‘%history’ command in Colab notebooks displays a history of codes and commands written
What does the ‘%magic’ command do in Colab notebooks?
The ‘%magic’ command in Colab notebooks provides information and documentation about available commands and their functionalities.
List all the special commands used in Colab notebooks - (7)
‘%cd’,
‘%pwd’, ‘
%ls’,
‘%ls -lt’,
‘%history’,
‘%magic’.
&mkdir
What does the ‘%mkdir’ command do
It creates a new directory within the current working directory.
Quick Exercise
Practice typing commands in the code window below and run them.
Check what your present working directory is and make a note of it (this might be your home directory on the system on which you are working)
Change to another directory to home
Check where your present working directory
Produce a new directory called test
List contents in test
Change current working directory to test
%pwd
Output: /content/sample_data
%cd /home (root then place we want to go)
Output: /home
%pwd - check where we are
Output: ‘/home’
%mkdir test
No output
%ls
Output: test/
%cd test
Output: /home/test
Identify the issue in the following Python code:
print(“Hello World!)
The issue in the code is the absence of a closing double quote, resulting in an “unterminated string literal” error - indicating that the provided string is not properly terminated with a closing double quote - syntax error
Explain the purpose of the + operator in the given Python code - (2)
print(“Hello” + “World”).
The + operator is used for string concatenation in the provided Python code.
It combines the strings “Hello” and “World” into a single string, “HelloWorld”.
What does the following code snippet do? - (3)
b = 10
print(b)
del(b)
print(b)
The code snippet assigns the value 10 to the variable b and prints it.
Then, it deletes the variable b using the del keyword.
Attempting to print b after it has been deleted will result in a NameError because the variable no longer exists.
Explain the behavior of type(float(3)) in Python.
The expression type(float(3)) converts the integer value 3 to a float and then determines its data type using the type() function.
Describe the outcome of int(3.25) in Python.
The expression int(3.25) converts the floating point number 3.25 to an integer, resulting in the value 3.
What is the result of int(3.999) in Python?
The expression int(3.999) converts the floating point number 3.999 to an integer, resulting in the value 3, as the conversion truncates the decimal part.
What arithmetic operations can be performed on numbers in Python?
Arithmetic operations such as addition (+), subtraction (-), multiplication (*), division (/), integer division (//), exponentiation (**), and remainder (%) can be performed on numbers in Python
What happens when executing print(3.0 + 3) in Python? - (3)
When running print(3.0 + 3), Python adds a floating point number (3.0) and an integer (3).
Python automatically converts the integer to a floating point number before performing the addition.
Forces the numbers to be same data type before performing addition.
Adding float to integer it will make it
float
If you keep everything the same datatype when doing arithmetic operations in print statement e.g., print(3 + 2) it will remain the
same data type - integer in this case
If you mix data types when doing arithmetic operations in print statement e.g., print(3.0 + 2) it will
typically become floating point values
What is the output of print(3.0 * 2) in Python?
The output is 6.0.
What is the output of print(3 * 2) in Python?
The output is 6.
Explain the behavior of print(3.0 ** 3) in Python.
It computes the result of raising 3.0 to the power of 3, which equals 27.0.
What does the expression print(9.0 ** 0.5) compute in Python?
It computes the square root of 9.0, which equals 3.0.
How does the power operator () behave in Python? - (2)
The power operator () can be used to compute both “normal” power values, such as squaring, and roots.
For example, raising a number to 1/2 (0.5) computes the square root.
How does division work in Python? - (2)
In Python, division is performed using the / operator.
It automatically converts integers to floating-point numbers ‘where necessary’.
What is the result of print(3 / 2) in Python?
The expression print(3 / 2) evaluates to 1.5 because it performs floating-point division, resulting in a floating-point number.
What does the // operator do in Python?
The // operator in Python performs integer division, discarding any fractional part and returning the integer result.
What is the result of print(3//2) in Python?
The expression print(3//2) evaluates to 1 because it performs integer division, resulting in an integer quotient - has not rounded it (chopped off decimal part)
What does the % (modulus) operator do in Python?
The % operator in Python returns the remainder of the division of the first number by the second number.
What is the result of print(8 % 3) in Python?
The expression print(8 % 3) evaluates to 2 because when 8 is divided by 3, the remainder is 2.
The ‘/’ allows integers to turn into
floating point numbers ‘where necessary’ (in other words if answer is not an integer)
The ‘//’ does not allow
integers to turn to floating point numbers ‘where necessary’ (in other words if answer is not an integer)
When using the integer division operator on floating point numbers, the division will be performed as if numbers were integer but result will be - (2)
floating point
e.g., print(3.0//2) in Python outputs the result of dividing 3.0 by 2 using integer division, resulting in 1.0.
What happens when you try to add a string and an integer in Python
print(3 + “dlfkjdofd”),? - (2)
When you try to add a string and an integer in Python, you get a exception (error) TypeError because Python does not support adding different types together.
In the given example, print(3 + “dlfkjdofd”), Python raises an exception because you cannot concatenate a string and an integer directly.
What type of error do you encounter when trying to add a string and an integer in Python?
When trying to add a string and an integer in Python, you encounter a TypeError.
What are collections of data in Python?
Collections of data in Python are structures designed to store multiple pieces of information.
What are the different types of collections of data in Python? - (3)
- Lists
- Tuples
- Dictionaries
What are lists - (2)?
A list is a collection of data that is ordered and changeable.
It allows you to store multiple items in a single variable.
What is the main difference between a list and a dictionary in Python?
The main difference between a list and a dictionary in Python is that a list is ordered and accessed by index, while a dictionary is unordered and accessed by key.
How are elements accessed in a list compared to a dictionary in Python?
In a list, elements are accessed by their index position, starting from 0. In a dictionary, elements are accessed by their key.
What are member functions in Python? - (2)
Member functions are built-in functions specific to a data structure that allow operations to be performed on that data.
They are called using the syntax: dataStructure.functionName(argument1, …).
What is the purpose of the append() member function in Python lists?
The append() member function adds a single value to the end of a list.
We can use append() many times to add many
elements to a list
What happens when you append a list to another list in Python?
When you append a list to another list using the append() member function, the entire second list becomes a single element of the first list.
What will be the output of print(my_main_list) after appending my_other_list to it?
my_main_list = [1, 2, 3]
my_other_list = [10, 20]
my_main_list.append(my_other_list)
- (2)
The output of print(my_main_list) will include my_other_list as a single element within my_main_list, preserving its structure
Output: [1, 2, 3, [10, 20]] and 4
What is the difference between using .append() and .extend() to add elements from one list to another in Python? - (2)
When using .append(), the entire second list is added as a single element to the first list.
In contrast, when using .extend(), each element of the second list is added individually to the first list.
What does it mean for Python to be a 0-indexed language?
In Python, being a 0-indexed language means that the first element in any sequence, including lists, is referred to as the “zeroth” element, and indexing starts from 0 rather than 1.
How do you access individual elements of a list in Python?
Individual elements of a list in Python are accessed using square brackets [], with the index of the desired element inside the brackets.
What does the code my_new_list[2] = ‘Hello’ do?
my_new_list = [‘ant’, ‘bear’, 10, 20]
print(my_new_list)
my_new_list[2] = ‘Hello’
print(my_new_list)
The code my_new_list[2] = ‘Hello’ replaces the third element in the list my_new_list with the string ‘Hello’.
The square bracket indexing syntax in lists can also be used to modify
an element in a list
note that Python wraps
indexing around with negative numbers.
How can you access elements from the end of a list in Python? - (2)
In Python, you can access elements from the end of a list using positive indices or by using negative indices.
For example, -1 refers to the last element, -2 refers to the second-to-last element, and so on.
What is the output of the code snippet provided?
print(my_new_list[-1]) do? - (2)
my_new_list = [‘ant’, ‘bear’, 10, 20]
print(my_new_list[-1])
print(my_new_list[-2])
20
10
What does the indexing notation [start:stop] in Python lists mean? - (2)
The indexing notation [start:stop] in Python lists is used to extract multiple elements from a list.
It specifies a range of indices from the start index (inclusive) to the stop index (exclusive), and returns a sublist containing the elements within that range.
The indexing notation for extracting multiple elements of list uses a
colon ‘:’
The indexing notation for extracting multiple elements of list uses a colon and its pattern is
[start:stop]
as Python is 0-indexed and end-points are exclusive bold text, the element
which has the last number will not be included
Explain the output of the given code snippet.
my_new_list = [‘ant’, ‘bear’, 10, 20]
Extract 1:3, meaning elements 1 and 2. Print the data and the length
print(my_new_list[1:3])
print(len(my_new_list[1:3]))
print(type(my_new_list[1:3]))
The code extracts elements at index 1 and 2 from my_new_list, prints the extracted elements ([‘bear’, 10]), their length (2), and their data type (<class ‘list’>).
Flashcard 3:
Missing start parameter in list slicing
my_new_list = [‘ant’, ‘bear’, 10, 20]
If we miss out the start parameter, the beginning of the list is presumed
print(my_new_list[:2]) # assumes start parameter is 0
Explain the output of the given code snippet – (2)
The code slices my_new_list from the beginning up to index 2 (exclusive), effectively extracting elements at index 0 and 1.
It prints [‘ant’, ‘bear’], assuming the start parameter as 0 when not explicitly provided.
Missing stop parameter in list slicing
my_new_list = [‘ant’, ‘bear’, 10, 20]
If we miss out the stop parameter, the end of the list is presumed
print(my_new_list[2:]) # assuming going right at end, 0 , 1, 10, 20
Describe the output of the given code snippet. - (2)
The code slices my_new_list from index 2 to the end, effectively extracting elements starting from index 2 to the end of the list.
It prints [10, 20], assuming the stop parameter is at the end of the list when it’s not explicitly provided.
Using the same number as start and stop in list slicing - (2)
python
Copy code
my_new_list = [‘ant’, ‘bear’, 10, 20]
If we use the same number as start and stop, we end up with an empty list
print(my_new_list[1:1]) # ‘[]’
What is the output of the given code snippet and why?
The code attempts to slice my_new_list from index 1 to index 1, resulting in an empty list [].
This happens because when the start and stop parameters are the same, no elements are included in the slice.
Assigning sliced data to a variable
my_new_list = [‘ant’, ‘bear’, 10, 20]
Extract 0:2, meaning elements 0 and 1. Put in a variable
my_data = my_new_list[0:2]
print(my_data)
What does the given code snippet do? - (2)
The code extracts elements at index 0 and 1 from my_new_list and assigns them to a new variable my_data.
It then prints the content of my_data, which would be [‘ant’, ‘bear’]
What does step parameter indicate in list slicing? [start:stop:step] - (2)
The step parameter in list slicing indicates the increment between each index when extracting elements from a list.
It allows for skipping elements based on the specified step size.
animals = [‘ant’, ‘bear’, ‘cat’, ‘deer’, ‘elk’, ‘frog’, ‘goose’, ‘horse’]
Extract every other item starting at index 1 and finishing at index 5
print(animals[1:5:2]) # start at 1 and finish at 5, exclude 5, go in steps of 2
Describe the output of the given code snippet.
The code extracts every other item from index 1 to index 5 (exclusive) in the animals list and prints the result: [‘bear’, ‘deer’].
animals = [‘ant’, ‘bear’, ‘cat’, ‘deer’, ‘elk’, ‘frog’, ‘goose’, ‘horse’]
We can miss out the start index and get everything from the start of the list
print(animals[:5:2])
What does the code snippet do, and what is its output? - (2)
The code slices animals from the beginning (0
-assumed) up to index 5 (exclusive) in steps of 2, effectively extracting every other item from the start of the list.
It prints the result: [‘ant’, ‘cat’, ‘elk’].
animals = [‘ant’, ‘bear’, ‘cat’, ‘deer’, ‘elk’, ‘frog’, ‘goose’, ‘horse’]
We can miss out the stop index and get everything to the end of the list
print(animals[1::2])
Question: Explain the output of the given code snippet. - (2)
he code slices animals from index 1 to the end of the list in steps of 2, effectively extracting every other item starting from index 1.
It prints the result: [‘bear’, ‘deer’, ‘frog’, ‘horse’].
animals = [‘ant’, ‘bear’, ‘cat’, ‘deer’, ‘elk’, ‘frog’, ‘goose’, ‘horse’]
We can even miss out the start and stop indices
print(animals[::2])
What does the code snippet do, and what is its output? - (2)
The code slices animals from the beginning to the end of the list in steps of 2, effectively extracting every other item from the list.
It prints the result: [‘ant’, ‘cat’, ‘elk’, ‘goose’].
animals = [‘ant’, ‘bear’, ‘cat’, ‘deer’, ‘elk’, ‘frog’, ‘goose’, ‘horse’]
And we can use any step we like, including negative numbers
print(animals[::-1]) # printing animals in reverse order
Describe the output of the given code snippet.
The code prints animals list in reverse order by slicing it with a step of -1: [‘horse’, ‘goose’, ‘frog’, ‘elk’, ‘deer’, ‘cat’, ‘bear’, ‘ant’].
Describe what the given code snippet does - (2)
my_special_number=[‘1’,’5’,’2’,’7’,’9’,’2’,’3’,’8’,’8’]
numbers_requested=my_special_number[0:8:3] # or write it as [0::3] or [::3], same output, or write in reverse do ‘[::-1]’
print(numbers_requested)
The code extracts every third number from the list my_special_number, starting with the first number, and prints the result: [‘1’, ‘7’, ‘3’].
my_special_number can be written as as [0::3] or [::3],
Some banks ask for a small subset of your ‘special number’ for verification purpose. Change the code below so that it prints out every third number starting with the first one.
my_special_number=[‘1’,’5’,’2’,’7’,’9’,’2’,’3’,’8’,’8’]
numbers_requested=my_special_number[xxxxx]
print(numbers_requested)
my_special_number=[‘1’,’5’,’2’,’7’,’9’,’2’,’3’,’8’,’8’]
numbers_requested=my_special_number[0:8:3] # or write it as [0::3] or [::3], same output,
print(numbers_requested)
What are the two main ways of removing elements of a list? - (2)
- Pop
- Del statement
Explain the functionality of the .pop() method when removing items from a list - (2)
The .pop() method in Python removes and returns the element at the specified index from a list.
It modifies the original list by removing the element and optionally allows you to storing the removed element in another variable.
Describe the purpose of the del statement when removing items from a list - (2)
The del statement in Python is used to remove an item or slice from a list by specifying its index.
It directly modifies the original list by deleting the specified item, and it does not return the removed item as .pop() does.
Describe what the given code snippet does using the .pop() method - (3)
my_list = [10, 20, 30, 40, 50]
print(my_list)
thing_removed = my_list.pop(2) #stores thing deleted which is 30
print(thing_removed) # prints out 30
print(my_list) # prints out list with ‘30’ deleted
The code removes the element at index 2 from the list my_list using the .pop() method.
It stores the removed element in the variable thing_removed which is ‘30’ and prints it.
Then, it prints the updated list (my_list) without the removed element ‘[10,20,40,50]’
Describe what the given code snippet does using the del statement - (2)
my_list = [10, 20, 30, 40, 50]
del my_list[0] #or use del statement to delete first element of list ‘10’
print(my_list) #prints new list with 10 removed
The code uses the del statement to remove the element at index 0 from the list my_list, which is ‘10’.
It then prints the updated list of my_list without the removed element: ‘[20,30,40,50]’
Question: Explain the functionality of the sorted function when sorting a list - (2)
The sorted function in Python returns a new list containing the elements of the original list sorted in ascending order.
It does not modify the original list, instead, it creates a new sorted list.
Describe the purpose of the .sort() method when sorting a list.
he .sort() method in Python sorts the elements of a list in ascending order in-place, meaning it directly modifies the original list.
It does not return a new list but instead sorts the elements within the original list itself.
Describe what the given code snippet does using the sorted function - (3)
my_num_list = [50, 40, 10, 20]
my_sorted_list = sorted(my_num_list)
print(my_sorted_list)
print(my_num_list)
The code snippet sorts the list my_num_list using the sorted function and stores the sorted result in the variable my_sorted_list which is [10,20,40,50]
It then prints both the sorted list of [10,20,40,50] and the original list [50,40,10,20]
The original list remains unchanged after sorting.
Describe what the given code snippet does using the .sort() method - (3)
my_num_list = [50, 40, 10, 20]
my_num_list.sort()
print(my_num_list)
The code snippet sorts the list my_num_list in-place using the .sort() method which is [10,20,40,50]
It directly modifies the original list, sorting it in ascending order.
Then, it prints the sorted list which is [10,20,40,50]
How would you define a tuple? - (2)
A tuple is an ordered collection of elements, similar to a list.
However, tuples are immutable, meaning their contents cannot be changed after creation.
What are the similarities and differences between tuples and lists? - (4)
Both tuples and lists can store multiple elements and can be indexed and sliced.
However, tuples are immutable meaning you can’t add or remove items to/from a tuple, while lists are mutable.
Tuples are typically used for fixed collections of data, while lists are used for collections that may need to be modified.
Differences between tuples and lists are tuples are defined using ‘()’ whereas lists use ‘[]’
We can create an empty tule using
round brackets ‘()’
What is the output of the given code snippet? - (4)
a = ()
Printing the type and content of the tuple
print(type(a))
print(a)
The output will display the type of the variable a, which is tuple, and an empty tuple ().
<class ‘tuple’>
()
The problem with creating an empty tuple is that
they cannot be changed - this therefore means that it will remain empty forever!
More commonly, we would create a tuple with
existing content:
What is the output of the given code snippet?
Creating a tuple with existing content
a = (1, 2, 3)
Printing the tuple
print(a)
The output will display the tuple (1, 2, 3) containing the numbers 1, 2, and 3.
With tuples you can perform tuple operations like - (2)
extract items from tuple e.g., my_tuple[1]
and count length of type using len()
What is the output of this code below?
Accessing an item in a tuple and getting its length
my_tuple = (5, 10, 15)
print(my_tuple[1]) # Accessing the second item in the tuple
print(len(my_tuple)) # Getting the length of the tuple
10
3
What happens when you attempt to modify an item in a tuple?
Modifying an item in a tuple will raise a TypeError exception since tuples are immutable and do not support item assignment.
What is output of this code?
Attempting to modify an item in a tuple (will raise a TypeError exception)
my_tuple = (5, 10, 15)
my_tuple[0] = 100 # This will raise a TypeError exception
TypeError: ‘tuple’ object does not support item assignment
if you have a tuple which you need to modify, you can cast it to (turn it into) a list and back again. This does not modify
the first tuple, but creates a new one with new content:
What is output of this code?
my_orig_tuple = (1, 2, 3, 4)
my_tmp_list = list(my_orig_tuple)
my_tmp_list[0] = 100
my_new_tuple = tuple(my_tmp_list)
print(my_orig_tuple)
print(my_new_tuple)
(1, 2, 3, 4)
(100, 2, 3, 4)
What does the provided code snippet do? - (2)
my_orig_tuple = (1, 2, 3, 4)
my_tmp_list = list(my_orig_tuple)
my_tmp_list[0] = 100
my_new_tuple = tuple(my_tmp_list)
print(my_orig_tuple)
print(my_new_tuple)
The code snippet converts the original tuple my_orig_tuple into a list my_tmp_list, modifies the first element of the list to 100, and then converts the modified list back into a tuple my_new_tuple.
It finally prints both the original and modified tuples.
What is the purpose of loops in programming?
Loops in programming are used to automate repetitive tasks, making coding more efficient and reducing manual effort
Examples of using lops to repeat simple operations that would be useful like
making lots of stimuli for an experiment or analyzing lots of different datasets.
Explain general structure of for loop - (4)
LOOPVARIABLE (which can be named whatever you want) will be set to the first item in LIST_OF_THINGS_TO_ITERATE_OVER.
The code which is indented (just a comment in this case) will then run.
Once all of the code which is indented has been run, the loop will go back to the top, LOOPVARIABLE will be set to the second item in LIST_OF_THINGS_TO_ITERATE_OVER and all of the indented code will run again.
This will repeat for each element in LIST_OF_THINGS_TO_ITERATE_OVER.
Describe this code -(4)
for t in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
print(“Hello!”)
print(“Hello”,t)
In the given code snippet, the for loop iterates over each element in the list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].
During each iteration, the loop variable ‘t’ takes on the value of the current element in the list.
Within the loop, the first print statement prints “Hello!” for each iteration, resulting in the message being printed 10 times.
The second print statement includes the value of ‘t’, causing “Hello” to be printed along with the current value of ‘t’ for each iteration, producing output where “Hello” is printed 10 times followed by “Hello” and the numbers 1 through 10 respectively.
What is the output of this code?
for t in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
print(“Hello!”)
print(“Hello”,t)
Hello!
Hello 1
Hello!
Hello 2
Hello!
Hello 3
Hello!
Hello 4
Hello!
Hello 5
Hello!
Hello 6
Hello!
Hello 7
Hello!
Hello 8
Hello!
Hello 9
Hello!
Hello 10
To ident code inside loop you can either use
4 spaces or tab
Create a for loop that produces 1-10
Output of this code and explain - (4):
Meaning:
print(x,x**2) is idented within for loop so we print each element in a list followed by itself squared:
In print(x.5) is not idented within for loop and identation is different from print(x,x2) so left the for loop
print(x,x**.5) square root the last element of the list (‘x’) which is 40 and prints “Done”
Output:
10 100
20 400
30 900
40 1600
6.324555320336759
Done
Explain this code and give its output:
Meaning:
The loop iterates over each element in the list my_list.
For each iteration, it prints “Hello”.
It computes the square of the current element (x) and stores it in y.
It then prints both the current element (x) and its square (y).
Output:
Hello
10 100
Hello
20 400
Hello
30 900
Hello
40 1600
You can run any code you want inside of a loop. One thing which you should not do however, is to - (2)
delete an item in a list whilst you are looping over the list.
This will cause hard to find problems in your code and almost certainly not do what you want
Write a code that has a list 10-100 stored in my_list = [] var
For loop that loops over that list and prints out value of x and its x squared and its square root on each iteration
What is output of the code?
What is nested for loops? - (3)
situation where one for loop is contained within another for loop.
This means that one loop runs inside another loop.
Each time the outer loop runs once, the inner loop can potentially run multiple times, depending on its own iteration behavior.
For nested for loops it is
important to follow the indentation carefully reading this code.
What is range() in Python? - (2)
built-in function used to generate a sequence of numbers.
It’s commonly used in loops to iterate over a specific range of numbers.
3 ways to use/call range() function - (3)
- range(stop)
- range(start,stop)
- range(start,stop,setp)
What is range(stop)
This generates a sequence of numbers starting from 0 up to (but not including) the specified stop value.
What is range(start,stop)?
This generates a sequence of numbers starting from start up to (but not including) the stop value.
What is range(start,stop,step) - (2)
This generates a sequence of numbers starting from start up to (but not including) the stop value, with a specified step size between each number.
The step parameter is optional and defaults to 1 if not provided
In python, all stop-style parameters are exclusive; i.e. - (3)
they are not included in the list which is returned.
This means that if we ask for range(0, 4), we will get the numbers 0, 1, 2, 3.
Forgetting how this works is a common source of bugs.
What will this output give you?
x = range(5)
print(type(x))
print(x)
<class ‘range’>
range(0, 5)
print the generator
What will this code give you?
x = list(range(5))
print(type(x))
print(x)
0 it is convert to list and print
<class ‘list’>
[0, 1, 2, 3, 4]
What will this code give you?
x = list(range(1, 500))
print(x)
[1, 2, 3, 4, 5, …., 499]
The step parameter in range… - (2)
sets the increment or decrement.
Setting this to be negative lets us count backwards.
What will these code give? - (3)
[1, 3]
[5, 4, 3, 2, 1]
[4, 3, 2, 1, 0]
range function generates a sequence of integer numbers within a specified range.
If you want to use floating point numbers then
use the arange function from the numpy module – we will cover this in a future session.
Sample exam questions
Q1.1
name = ‘Alice”
# What is wrong with this line of code? - (3)
The quotes do not match.
Either use all single quotes or all double quotes.
For example, name=’Alice’
Q1.2
age = ‘23’
print(age + 2)
# Why does this code raise an error? - (2)
age is a string variable but you are adding an integer to it.
Variable types have to match when doing arithmetic
Q1.3
fruits = [‘apple’, ‘banana’, ‘cherry’]
fruits[3] = ‘orange’
# What is incorrect with this code? - (2)
The list only has 3 entries but you are trying to access the fourth one.
Python indexing starts at zero.
Q1.4
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined_list = list1 + list2
print(combined_list)
# What will this print, and why might it confuse a beginner? - (2)
This will concatenate the lists: [1,2,3,4,5,6]
You might be expecting it to add them element by element [5,7,9], or even include list2 as a member of list 1 [1,2,3,[4,5,6]]
Q1.5
my_tuple = (1, 2, 3)
my_tuple[1] = 4
# What concept does this example illustrate, and what is the mistake? - (3)
You cannot change tuples once you make them.
Here you are trying to alter the second element in the tupe.
You can’t.
Q1.6
numbers = [1, 2, 3, 4, 5]
for number in numbers:
print(num)
# Identify and correct the mistake in this loop - (2)
The variable ‘num’ is not defined. That line should read
print(number)
for i in range(5):
print(“Number is: “, i)
# What will be the output of this loop, and what common misunderstanding might this clarify? - (2)
0,1,2,3,4
It will demonstrate that python ranges are zero indexed and exclusive (they start at zero and do not include the last number)
for i in range(3):
for j in range(2):
print(i, j)
# What will be the output of this nested loop, and what concept does it illustrate? - (3)
0 0
0 1
1 0
1 1
2 0
2 1
Ranges start at zero and exclude the highest element. Also loop blocks are defined by indentation.
And nested loops are evaluated from the deepest loop out.
name = “John”
greeting = “Hello, name!”
print(greeting)
# Why doesn’t this code snippet print “Hello, John!”? - (3)
The variable ‘name’ and the word ‘name’ inside the string are different things.
You could write
print(“Hello”,name)
To get the right answer.
def multiply(x, y):
return x * y
print(multiply(2))
# What error will this code produce and why?
function looks like it takes two arguments (x and y) but you are only providing one argument when you call it (2)
%pwd
%cd ..
%ls
# Explain what each of these ‘magic’ / or ‘shell’ commands does - (3)
pwd = print the working directory
cd = change directory (in this case to the one above)
ls = list the contents of the current directory
my_string = “Hello, World!”
print(my_string[-1])
What will be printed when executing this code, and what concept does it illustrate? - (2)
The code will print the last character of the string, which is “!”.
This illustrates the concept of negative indexing in Python, where -1 refers to the last element, -2 refers to the second last, and so on.
my_list = [1, 2, 3, 4, 5]
print(my_list[2:4])
What output will this code produce, and why? - (3)
The code will print [3, 4].
This is because slicing with the notation [start:stop] returns a sublist containing elements from index start up to (but not including) index stop.
In this case, it extracts elements at indices 2 and 3 from my_list.
my_list = [1, 2, 3, 4, 5]
my_list[1:4] = [8, 9, 10]
print(my_list)
What will the final contents of my_list be after executing this code? - (2)
The final contents of my_list will be [1, 8, 9, 10, 5].
This code replaces elements at indices 1, 2, and 3 in my_list with the elements [8, 9, 10], resulting in the modified list.
my_list = [‘apple’, ‘banana’, ‘cherry’]
print(my_list[::-1])
What will be printed when running this code, and what is the purpose of the slicing notation used? - (2)
The code will print [‘cherry’, ‘banana’, ‘apple’], which is the reversed version of my_list.
The slicing notation [start:stop:step] with step as -1 is used to reverse the order of elements in the list.
What is a modern and preferred method for combining data and strings for output formatting in Python, beside using commas?
Using f-strings, which provide a more elegant and concise way to format output by embedding variables directly into strings.
What does f-strings stand for in Python?
An f-string, short for “formatted string literal,”
How do you create an f-string in Python?
Prefix the string with the letter ‘f’, (just before te quote marks) then use curly braces {} to enclose the variable names you want to include in the string.
What happens when an f-string is evaluated in Python?
When an f-string is evaluated, Python replaces the expressions enclosed within curly braces {} with their corresponding values at runtime, resulting in a formatted string.
Explain this code - (4)
the variable my_variable is assigned a value of 100.
Then, an f-string named foo is created, where the value of my_variable (100) is embedded within the string using curly braces {} .
When foo is printed, it will display the string “My variable contains the value 100”.
The ‘f’ prefix before the string indicates that it is an f-string, and Python replaces the expression {my_variable} within the string with the value of the variable during runtime.
Example of adding multiple variables in f-string in Python
How can you force a value to occupy a certain amount of space using f-strings in Python? -
By adding a colon followed by the desired width after the variable name inside curly braces {} in the f-string.
What would be output of this code?
Q: Explain the purpose of the following f-string
myvar = ‘Test’
print(f’==={myvar:20}===’): - (3)
The output ===Test === consists of the string “===” at the beginning and end, with the variable myvar (“Test”) occupying 20 spaces.
Output is:
===Test ===
Since the word “Test” has only 4 characters, it is followed by 16 spaces to fill the specified width.
How to change allignment of variable in f-string?
You can change the alignment by adding a character before the width number inside curly braces {} in the f-string:
What is the default alignment behavior of a string in f-strings?
By default, strings are left-centered in the space provided within an f-string.
What is the output of the following f-string?
The output would be ===TestText ===, with the string “TestText” occupying 8 characters and the remaining 12 spaces filled with whitespace to the right, resulting in left alignment of string “TestText” within the specified width.
What is the output of the following f-string?
The output would be
‘=== TestText===’, with the string “TestText” occupying 8 characters and the remaining 12 spaces filled with whitespace to the left, resulting in right alignment of string “TestText” within the specified width.
What is output of the following f-string? - (2)
The output would be:
=== TestText ===
with the string “TestText” occupying 8 characters and evenly distributed whitespace of 12 spaces on each side, resulting in center alignment of string “TestText” within the specified width.
How does f-string handle space expansion when the inserted string is longer than the specified width?
F-strings expand the space to fit the entire string when it is longer than the specified width
What is the output of this code? - (3)
variable myvar containing the string ‘TestTextVeryLong’ is inserted into the f-string with a specified width of 5 characters
Despite the specified width being only 5 characters, Python expands the space to accommodate the entire string when necessary
So output becomes: ===TestTextVeryLong===
What is the output of the code print(f’==={myvar:^7}===’) where myvar = 500000090? - (2)
The output is ===500000090===, which shows the large number 500000090 centered within a 7-character space.
Since the number itself is longer than the specified width, the f-string expands the space to accommodate the entire number, ensuring no truncation occurs.
What is the purpose of zero-padding integers in Python (using f-strings with numbers)? - (3)
Zero-padding integers involves adding leading zeros to the integer to ensure it fills a specific width.
This adding 0s before the number to fill the space rather than spaces
This is often useful when naming files to make sure that they sort correctly (e.g. if using participant numbers).
What is the output of the code print(f’{mynum:03}’) where mynum = 5? - (2)
The output is 005, which demonstrates the integer 5 zero-padded to fill a width of 3 characters
Since 5 is 1 character, it adds 3 zeros before to fill the width of 3 characters
How can you control the number of decimal places in floating point numbers using f-strings?
You can control the number of decimal places in floating point numbers by specifying the desired number of digits after the decimal point in the format specifier, such as {myval:10.4f}
What is the output of
print(f’=={myval:10.4f}==’)
where myval = 10.219? - (3)
The output is
== 10.2190==
This displays the floating-point number 10.219 with a total width of 10 characters, including three leading spaces followed by the number with four digits after the decimal point.
The zero at the end is added to fill the specified precision of four decimal places.
What is the output of print(f’=={myval:7.2f}==’)
where myval = 10.219? - (3)
The output is == 10.22==. This result is achieved because the formatting specifier 7.2f is used, indicating that the number should be displayed with a total width of 7 characters, including two digits after the decimal point.
Python rounds the number 10.219 to 10.22 to meet the specified formatting requirements - width and precision of decimal places
Additionally, two leading spaces are added to ensure that the number is properly aligned within the specified width.
What happens if you ask for fewer decimal places in f-strings in Python?
Python rounds the numbers to the specified number of decimal places
What character is used for scientific notation in f-strings?
The e formatting character is used for scientific notation in f-strings.
How is scientific notation represented using the “e” formatting character? - (2)
Scientific notation using the “e” formatting character is expressed as a number multiplied by 10 raised to a power, denoted by “e”.
For example, “1.0e-6” represents 1.0 × 10^(-6).
What is the output of the code print(f’==={myval:e}===’)
where myval = 0.000001?
The output is “===1.000000e-06===”, which represents the number 0.000001 in scientific notation.
How can you control the number of decimal places in scientific notation when using the “e” formatting character in f-string? - (2)
You can control the number of decimal places in scientific notation by specifying the desired precision after the colon, similar to using the “f” formatting character.
For example, print(f’==={myval:.1e}===’) will display the number in scientific notation with one decimal place.
What happens if the provided number of spaces is not sufficient for the number when using the “e” formatting character?
If the provided number of spaces is not sufficient for the number when using the “e” formatting character, extra spaces will be added to accommodate the full representation of the number.
What is the purpose of specifying “.1e” in the code print(f’==={myval:.1e}===’)?
Specifying “.1e” limits the number of decimal places to one in the scientific notation representation of the number.
What is the output of the code print(f’==={myval:.1e}===’) where myval = 0.000001? - (3)
The output is ===1.0e-06===.
This notation represents the number 0.000001 in scientific format, where “1.0” denotes the main numerical value, “e” signifies “times ten to the power of”, and “-06” indicates the exponent, signifying that the number is multiplied by 10 to the power of -6.
The “.1” specifier in the f-string limits the number of decimal places to one.
What is the output of the code print(f’==={myval:10.1e}===’) where myval = 0.000001? - (4)
he total width specified is 10 characters.
The scientific notation 1.0e-06 itself takes up 7 characters (1.0e-06).
To ensure right alignment within the total width of 10 characters, three additional spaces are added before the number.
Therefore, there are three spaces before the number 1.0e-06 to make up the total width of 10 characters.
What does ‘d’ mean in f-string formatting?
In f-string formatting, ‘d’ is used to specify that the value should be formatted as an integer.
What is the purpose of the f-string expression {part_id:03d} in the code - (2)
print(f’| P{part_id:03d} | {num_trials:3d} | {rt:8.3f} |’)?
The expression {part_id:03d} formats the integer value part_id with leading zeros to make it three characters wide.
For example, if part_id is 1, it will be formatted as ‘P001’.
What is the purpose of the f-string expression {num_trials:3d} in the code print(f’| P{part_id:03d} | {num_trials:3d} | {rt:8.3f} |’)? - (2)
The expression {num_trials:3d} right-aligns the integer value num_trials within a minimum width of three characters.
If the integer has fewer than three digits, it will be padded with spaces on the left.
What is the purpose of the f-string expression {rt:8.3f} in the code print(f’| P{part_id:03d} | {num_trials:3d} | {rt:8.3f} |’)? - (2)
The expression {rt:8.3f} formats the floating-point number rt with a total width of 8 characters, including three decimal places.
It ensures that the number is right-aligned within the specified width.
What is output of the code?
P001 | 100 | 100.210 |
Explain this code - (2)
This code creates a table displaying participant information using three lists: part_ids for participant IDs, trial_counts for the number of trials each participant did, and rts for their reaction times.
It iterates over the indices of the part_ids list using a for loop. Within the loop, it prints a formatted table line for each participant, where their ID is zero-padded to three digits, the trial count is right-aligned with three spaces, and the reaction time is displayed with three decimal places, using f-strings for formatting.
What is the purpose of the input function in Python? - (3)
The input function in Python is used to request information from the user.
It takes a string argument, known as the “prompt,” which is displayed to the user, prompting them to input some data.
Once the user provides input, the input function returns the data entered by the user.
What is the data type of the value returned by the input function? - (2)
the input() function returns a string data type.
This means that regardless of what the user inputs (whether it’s numbers, letters, or symbols), it will be treated as a string unless explicitly converted to another data type using functions like int(), float(), etc.
What is the output of the following code snippet? - (3)
data = input(‘Enter a word: ‘)
print(type(data))
print(data)
The output of the code snippet depends on the user input.
When prompted to enter a word, if the user enters “zebra,”
the output will be:
<class ‘str’>
zebra
What is output? if user input is 10
Enter a number: 10
‘<class ‘str’>’
10
‘<class ‘int’>’
10
20
Explain this code if user input is 10 - (2)
The user input is initially of type string (str), but after casting it to an integer using int(), its type becomes int.
When the value is multiplied by 2, the result is 20
Write a script which inputs two numbers. The first should be a number to count from, the second a number to count to. Once the user has input the numbers, you should print - using a loop - all of the numbers between the starting and ending number (inclusive; think carefully about this), one per line.
An example run of the program might look like this:
Starting number: 5
Ending number: 10
5
6
7
8
9
10
What does the following Python code do? - (3)
first_number = int(input(‘Enter a number to start: ‘))
second_number = int(input(‘Enter a number to end: ‘))
for x in range(first_number, second_number + 1):
print(x)
The code begins by prompting the user to input two numbers, which are then converted to integers using the int() function.
It then uses a for loop to iterate over the range from first_number to second_number + 1.
The +1 ensures that the range includes the second_number.
Inside the loop, each number in the range is printed on a separate line.
This allows the loop to print all numbers from first_number to second_number, inclusive.
What is a dictionary in Python?
A dictionary in Python is a collection of key-value pairs, where each key is linked to a corresponding value.
How are dictionaries defined in Python? - (2)
Dictionaries are defined with curly brackets and key-value pairs,
for example: my_dict = {‘key1’: ‘value1’, ‘key2’: ‘value2’}.
Unlike real dictionaries where one word can have many meanings, in Python dictionaries:
Each key can only have a
a single value
How do we create an empty dictionary in Python?
We create an empty dictionary in Python using curly braces {}.
What is the type of an empty dictionary in Python?
The type of an empty dictionary in Python is dict.
What type of brackets are used for indexing in Python dictionaries?
Python uses square brackets [] for indexing in dictionaries.
Explain the following Python code - (2)
my_dict = {}
print(my_dict)
print(type(my_dict))
This code initializes an empty dictionary named my_dict using curly braces {}.
It then prints the contents of the dictionary, which is an empty dictionary {}, and its type, which is <class ‘dict’>.
What is output of this code? - (2)
my_dict = {}
print(my_dict)
print(type(my_dict))
{}
<class ‘dict’>
How to add items to a dictionary in Python with an example: - (4)
Items can be added to a dictionary in Python using square bracket notation.
Specifically, you assign a value to a key within the dictionary using square brackets.
For example:
my_dict = {}
my_dict[‘mykey’] = 20
This code snippet creates an empty dictionary my_dict and then assigns the value 20 to the key ‘mykey’.
What is the output of the code below?
my_dict = {}
my_dict[‘mykey’] = 20
my_dict[‘anotherkey’] = 100
my_dict[‘Averylongkeyblahblahblah’] = 1
my_dict[‘Navin R Johnson’] = ‘253.125 Elm St’
print(my_dict)
{‘mykey’: 20, ‘anotherkey’: 100, ‘Averylongkeyblahblahblah’: 1, ‘Navin R Johnson’: ‘253.125 Elm St’}
Explain this code - (2)
my_dict = {}
my_dict[‘mykey’] = 20
my_dict[‘anotherkey’] = 100
my_dict[‘Averylongkeyblahblahblah’] = 1
my_dict[‘Navin R Johnson’] = ‘253.125 Elm St’
print(my_dict)
print(f’There are {len(my_dict)} keys in the dictionary’)
This code initializes an empty dictionary my_dict and then adds several key-value pairs to it using square bracket notation.
After printing the dictionary, it also displays the number of keys in the dictionary using the len() function.
What will be the output of this code? - (2)
my_dict = {}
my_dict[‘mykey’] = 20
my_dict[‘anotherkey’] = 100
my_dict[‘Averylongkeyblahblahblah’] = 1
my_dict[‘Navin R Johnson’] = ‘253.125 Elm St’
print(my_dict)
print(f’There are {len(my_dict)} keys in the dictionary’)
{‘mykey’: 20, ‘anotherkey’: 100, ‘Averylongkeyblahblahblah’: 1, ‘Navin R Johnson’: ‘253.125 Elm St’}
There are 4 keys in the dictionary
As explained above, we can only have one instance of a single key in a given dictionary at any one time. So, what happens when we try to add a key more than once?
What happens when we try to add a key more than once in a dictionary in Python?
When we try to add a key more than once in a dictionary, the existing value associated with that key is replaced by the new value.
Example of we try to add a key more than once in a dictionary, the existing value associated with that key is replaced by the new value.
What is output of this code? - (2)
{‘mykey’: 20}
{‘mykey’: 2000000}
Explain this code - (6)
In this code, we start with an empty dictionary my_dict.
We add a key-value pair to the dictionary where the key is ‘mykey’ and the value is 20.
When we print the dictionary, it displays {‘mykey’: 20}.
Next, we attempt to add another value to the same key ‘mykey’, this time with the value 2000000.
However, since dictionaries in Python can only have unique keys, the existing value associated with ‘mykey’ is replaced by the new value.
Therefore, when we print the dictionary again, it shows {‘mykey’: 2000000}.
How do you extract individual values from a dictionary in Python? - (2)
To extract individual values from a dictionary in Python, you use square bracket notation with the key of the desired value.
It is the same index (square bracket) notation used to add entries and also same notation used to extract items in lists
Example of extracting values in a dictionary
What is the output of this code? - (2)
20
<class ‘int’>
Explain this code snippet - (3)
The code initializes an empty dictionary my_dict, then adds a key-value pair where the key is ‘mykey’ and the value is 20.
It extracts the value corresponding to the key ‘mykey’ using square bracket notation which is 20 and assigns it to the variable test_var.
Finally, it prints the value of test_var which is 20 and its type which is <class ‘int’>.
What happens if you try to extract a value using a key that does not exist in the dictionary?
you will get a KeyError exception.
Example of keyerror exception
How can we extract a value from a dictionary without encountering a KeyError if the key does not exist?
We can use the .get() function in Python dictionaries.
What does the .get() function return if the specified key does not exist in the dictionary?
By default, the .get() function returns None if the specified key does not exist in the dictionary.
What is the output of this code? - (3)
1000
<class ‘NoneType’>
None
What does this following code snippet demonstrate? - (4)
This code snippet demonstrates the creation of an empty dictionary my_dict, followed by adding a key-value pair to it which has a key of ‘mykey’ and value of 1000
Then an attempt is made to retrieve value associated with non-existent key ‘mykey_notthere’ using .get() and storing in variable ‘my_val’
Since no default value is provided, the function returns None.
Finally, the type and value of my_value are printed which is <class ‘NoneType’> and value is None
Example of dictionary already having stuff in it
This requires use of : and , characters
How can items be deleted from a dictionary in Python?
As with lists, Items can be deleted from a dictionary in Python using either the .pop() or del functions.
What does the .pop() function return when used to delete an item from a dictionary?
The .pop() function returns the value of the deleted item.
What does the del function do when deleting items from a dictionary? - (2)
The del function in Python is used to remove an item with a specified key from a dictionary.
It deletes the key-value pair associated with the specified key from the dictionary
Both pop and del functions in lists and dictionaries in general
deletes the key-value pair associated with the specified key from the dictionary
What is the difference between using .pop() and del to delete items from a dictionary?
The .pop() function returns the value of the deleted item, while del does not return any value.
What does this code snippet do? - (8)
This code snippet creates a dictionary called my_new_dict with two key-value pairs: ‘age’: 35 and ‘test_value’: 1000.
It then prints out contents of my_new_dict: {‘age’: 35, ‘test_value’: 1000}
It then demonstrates two methods for deleting items from the dictionary.
First, it uses the pop() function to remove the key ‘age’ from the dictionary my_new_dict .
The value associated with the key ‘age’ (35) is stored in the variable removed_value, which is then printed.
After removal, the dictionary my_new_dict is printed again {‘test_value’: 1000}, showing that the key-value pair ‘age’: 35 has been removed from the dictionary.
Next, it uses the del keyword to delete the key ‘test_value’ from the dictionary called my_new_dict.
Then the updated dictionary my_new_dict is printed which is indeed empty since both key-value pairs have been removed.
What is the output of this code? - (4)
{‘age’: 35, ‘test_value’: 1000}
35
{‘test_value’: 1000}
{}
How can you check if a specific key exists in a dictionary in Python? - (2)
By using the in keyword
In which ‘key’ is in quotes followed by in keyword which is followed by dictionry name
An example of using in keyword in dictionaries
For example P1 in ages will return True if P1 is a key in ages
What is the output of this code? - (2)
P1 is a key? : True
P1000 is a key? : False
What does the expression ‘P1000’ in ages return if ages is a dictionary containing keys ‘P1’: 35, ‘P2’: 38, ‘P3’: 21, ‘P4’: 28, ‘P5’: 33?
False, because there is no key ‘P1000’ in the ages dictionary.
How do you print all the keys in a dictionary in Python? - (2)
To print all the keys in a dictionary named ages, you can use the keys() method like this: print(ages.keys()).
This method returns all the keys in the dictionary.
Explain this code snippet - (3)
This code snippet creates a dictionary called ages with keys representing participant IDs and values representing their ages.
Then, it prints out the keys of the dictionary using the keys() method which gives: dict_keys([‘P1’, ‘P2’, ‘P3’, ‘P4’, ‘P5’])
Finally, it prints the type of the value returned by ages.keys(), which is <class ‘dict_keys’>
What is output of this code? - (2)
dict_keys([‘P1’, ‘P2’, ‘P3’, ‘P4’, ‘P5’])
<class ‘dict_keys’>
Although in this example the keys appear to be in order we entered them that is not guaranteed by Python and may need to
sort keys using sorted() function or sort() with Python dictionaries (don’t need to convert to list to sort them)
How can you convert dictionary keys/values into a list in Python?
You can convert the keys/values into a list by simply ‘casting’ (converting) the return value to the list type using list() function
Explain the following code snippet - (6)
It retrieves the keys from the dictionary ages using the keys() method.
It converts these keys into a list using the list() function.
It assigns the resulting list to the variable my_keys.
It prints the datatype of my_keys using type() which is <class ‘list’>
It prints the contents of my_keys: [‘P1’, ‘P2’, ‘P3’, ‘P4’, ‘P5’]
It prints the length of my_keys using len() which is 5
What is output of this code? - (3)
<class ‘list’>
[‘P1’, ‘P2’, ‘P3’, ‘P4’, ‘P5’]
5
How do you retrieve just the values from a dictionary in Python?
Using the .values() function, which returns all the values in the dictionary
In Python dictionaries, you cannot directly access a key by
its value will return exception error
What does the following Python code snippet do? - (4)
Has a dictionary age which has participants’ IDs as keys and their ages as values: ages = {‘P1’: 35, ‘P2’: 38, ‘P3’: 21, ‘P4’: 28, ‘P5’: 33}
This code snippet retrieves all values from the ages dictionary using the .values() function, and prints them: dict_values([35, 38, 21, 28, 33])
It then prints the type of the returned values from age dictionary: <class ‘dict_values’>
Additionally, it casts the values from age dictionary into a list using list() and store into variable called ‘my_vals’ and prints out ‘my_vals’: [35, 38, 21, 28, 33]
What is output of this code? - (3)
dict_values([35, 38, 21, 28, 33])
<class ‘dict_values’>
[35, 38, 21, 28, 33]
What is output of this code?
Mean age of participants is: 37.0
There are several ways to loop over dictionaries to do something to each key/value pair
Two ways are - (2)
1) loop over keys and using dict[key]
2) .items() iterator
Example of looping over dictionaries
First method of loop over keys and using dict[ky]
What will be output of the code?
P1 35
P2 38
P3 21
P4 28
P5 33
What is the default behaviour of a dictionary in a for loop?
iterate over the keys:
How does the provided code iterate over a dictionary and print each key along with its corresponding value? - (3)
The code iterates over the keys of the dictionary ages using a for loop.
During each iteration, it accesses the key k and retrieves its corresponding value from the dictionary using dictionary indexing (ages[k]).
Then, it prints both the key and its corresponding value.
How can we access both the keys and values of a dictionary during each iteration of a loop without using dictionary indexing? - (2)
We can use the .items() iterator, which returns key/value pairs one at a time.
This allows us to access both the key and the value directly within the loop without needing to use the dict[key] syntax.
Explain how the given code snippet iterates over a dictionary and prints each key-value pair - (3)
The code snippet uses a for loop with the .items() iterator to iterate over the dictionary ages.
During each iteration, the keyThing variable is assigned the key, and the valThing variable is assigned the corresponding value.
These key-value pairs are then printed using the print() function.
What is output of the code?
P1 35
P2 38
P3 21
P4 28
P5 33
What is noteworthy about the .items() method used in the given code snippet? - (2)
The .items() method returns key-value pairs from the dictionary, and these pairs are automatically unpacked and assigned to the loop variables keyThing and valThing.
This makes the code more concise and readable,
The sorted function in Python sorts the
dictionary based on keys not valuees by default
Explain this code: - (5)
The code begins by defining the number of subjects (numSubjects) as 3 and initializes an empty dictionary called ageDict to store participant IDs and ages.
It then enters a loop that iterates three times (for each subject).
Within this loop:
It prompts the user to input a participant ID (partID) and age (partAge).
It stores the entered ID and age as key-value pairs in the ageDict dictionary.
After collecting all the data, it prints out the contents of the ageDict dictionary.
Following this, the code enters another loop that iterates over the sorted items of the ageDict dictionary. This loop:
Uses the sorted() function to sort the dictionary items by keys.
Iterates over the sorted items using the items() iterator, which returns key-value pairs.
Unpacks each key-value pair (ID and age) from the sorted dictionary items.
Formats and prints each ID and age pair using an f-string, ensuring alignment and spacing for readability.
What is the difference between a ‘for’ loop and a ‘while’ loop?
‘for’ loops iterate over a list of values for a fixed number of times, while ‘while’ loops continue iterating as long as a certain condition is met.
What caution is given regarding ‘while’ loops?
‘while’ loops can lead to infinite loops if not properly controlled, potentially causing the program to become unresponsive.
How can one escape an infinite loop?
To escape an infinite loop, one can use the Ctrl-C keyboard shortcut (holding down the Ctrl button and pressing C simultaneously) or use the stop button available in coding environments like Colab or Spyder.
What is a while loop in Python? - (2)
A while loop is a control flow statement that repeatedly executes a block of code as long as a specified condition is true.
It continues to execute the block until the condition becomes false.
While loops are useful when the
number of iterations is not known in advance.
Explain the purpose of the while loop in the provided code snippet - (5).
The while loop continuously executes the block of code inside it as long as the condition a < 5 remains true.
Inside the loop, a is incremented by 1 each time.
The loop stops when a becomes equal to or greater than 5.
After the loop finishes, “Done” is printed.
Note the += syntax here: this is the same as writing a = a + 1.
What is output of this code?
1
2
3
4
5
Done
What is the crucial aspect to ensure in a while loop? - (2)
The crucial aspect is to ensure that the condition being tested will eventually evaluate to True.
If this condition never becomes False, the loop will continue indefinitely.
2.5.1 Quick Exercise
Create a list containing the words apple, banana, cherry and damson. Write a while loop which iterates over the list and prints out the words one at a time. You will need to have the while loop count over the indices and exit when you get to the end of the list.
A conditional statement is one that allows us to make..
The programme can change what it does - (2)
a decision when the program is running.
next depending on what is happening now.
A conditional statement allow the program to execute different blocks of code depending on whether
a condition is true or false.
The conditional statement is expressed in Python using key word
if
‘else’ keyword is used in conjunction with
‘if’
‘else’ provides an
alternative block of code to execute when the condition specified with if is false.
‘elif’ allows you to check- (3)
for multiple conditions sequentially after an initial if statement.
If the condition associated with if is false, it checks the condition associated with elif and executes the corresponding block of code if true.
You can have multiple elif statements.
‘if’ statement in Python evaluates - (2)
a condition, which can be any expression that results in a boolean value (True or False).
This condition determines whether the subsequent code block associated with the if statement is executed.
The general form of if is: if CONDITION. CONDITION can be anything which evaluates to a bool - i.e. True or False. Here we are - (2)
we are comparing numbers
e.g., ‘if a > 10’: this condition evaluates whether value of ‘a’ is greater than 10
As with for loops, blocks of statements which are inside an if need to be
indented
Example image of else statement used in conjunction with if CONDITION
You do not have to have a
else statement (i.e., with if statement or in any loops like for and while)
The else statement, if it exists, must always be the final part of the
if block
What is output of this code? - (2)
Test subject with age 9999 ignored
The total of all the real ages is 155
‘elif’ statement is a neat way of stringing together lots of
statements in a row
Write a code:
storing number ‘66’ into variable called subjectAge
if age of pp is greater than 65 it prints: “Age is too big”
if age of pp is less than 18 then print “Age too small!”
Otherwise, it would print subject age okay!
What is output of this code? - (6)
Output: Age too big!
This code evaluates the value of the variable subjectAge, which is initially set to 66.
Since subjectAge is greater than 65, it prints “Age too big!”.
The elif statement checks for additional conditions, but they are not met because subjectAge does not fall below 18.
Hence, it doesn’t print “Age too small!”.
Finally, the else block is bypassed, and the code prints “Subject age okay!”.
Explain the code, what would be output and why? - (11)
In this code, there are nested if statements. T
he outer if statement checks if the subjectAge is greater than 18.
If this condition is true, it then checks the numberOfFunctionalEyes.
If numberOfFunctionalEyes is equal to 2, it prints “Subject is valid”.
If numberOfFunctionalEyes is not equal to 2, it prints “Right age, wrong number of eyes”.
If the subjectAge is not greater than 18, it prints “Under age, didn’t check the eyes”.
Given subjectAge = 19 and numberOfFunctionalEyes = 1, here’s what happens:
The first condition subjectAge > 18 is true, so it proceeds to the nested if statement.
However, the second condition numberOfFunctionalEyes == 2 is false since numberOfFunctionalEyes is 1.
Therefore, it executes the else block of the nested if statement.
Hence, the output would be “Right age, wrong number of eyes”.
In our examples so far, the conditions that we have used have been comparisons (greater than, equal to, less than).
As noted above, if statements work with any statement which can evaluate to a bool value (True or False).
You can also write out more complex statements than just checking the value of a variable.
e.g,.
such as using a the ‘modulus’ operator % in if statement and using string operations such as ‘startswith’ and ‘endswith’
Remember:
Modulus operator ‘%’ returns the
‘remainder’ when you divide one thing by another thing.
Write a code that
stores number 4 into variable ‘a’
Checks if a is odd
Explain this code - (4):
a = 4: This line assigns the value 4 to the variable a.
if (a % 2) == 1:: This line sets up a conditional check. Inside the parentheses, (a % 2) computes the remainder when a is divided by 2, effectively determining whether a is even or odd.
(a % 2) will result in 0 if a is even and 1 if a is odd.
if the condition (a % 2) == 1 evaluates to True (which is the case when a is odd), the program prints “a is odd”.
However, in this case, the condition evaluates to False since a is even.
What is output?- (2)
Since the condition (a % 2) == 1 evaluates to False when a is 4 (because 4 % 2 equals 0, not 1), the print(“a is odd”) statement will not be executed.
Therefore, there will be no output for this code when a is assigned the value 4.
How do we compare strings in Python code?
we can compare strings using equality operator ==:
Write a code that compares strings to see if “Hello” and “Hello” are the same and if “Hello” and “Hello World” are the same that is stored in variables a, b, c
What would be output of this code?
Explain this code and why it produces that output? - (4)
This code initializes three variables a, b, and c with string values. Then it performs comparisons using the equality operator == to check if the strings are the same.
a = “Hello”: Assigns the string “Hello” to the variable a.
b = “Hello”: Assigns the string “Hello” to the variable b.
c = “Hello World”: Assigns the string “Hello World” to the variable c.
if a == b:: Compares the strings stored in variables a and b. Since both a and b contain the same string “Hello”, this condition evaluates to True. Therefore, it prints “a and b are the same”.
if a == c:: Compares the strings stored in variables a and c. However, a contains “Hello” and c contains “Hello World”, so these strings are different. This condition evaluates to False. Therefore, it prints “a and c are different”.
We can also perform advanced string operations such as checking whether one string starts with another using the
‘startswith’ member function
Write a code that:
stores
variable a into “hello”
variable b into “world”
variable c with “hello world”
Check if c starts with a and prints a starts with a if not then say it does not
Check if c starts with b and prints c starts with b or if not then say it does not
What is the output of this code?
Explain the output of the code and justify why it produces that output. - (4)
This code snippet initializes three string variables: a with the value “Hello”, b with the value “World”, and c with the value “Hello World”. Then, it utilizes the startswith method to check if the string c starts with the substrings represented by variables a and b.
a = “Hello”: Assigns the string “Hello” to the variable a.
b = “World”: Assigns the string “World” to the variable b.
c = “Hello World”: Assigns the string “Hello World” to the variable c.
if c.startswith(a):: Checks whether the string c starts with the substring represented by variable a (“Hello”). Since the string c does indeed start with “Hello”, this condition evaluates to True, and “c starts with a” will be printed.
if c.startswith(b):: Checks whether the string c starts with the substring represented by variable b (“World”). Since the string c does not start with “World”, this condition evaluates to False, and “c does not start with b” will be printed.
There is a corresponding counterpart to ‘startswith’ member function there is also a
‘endswith’ that is another advanced string operator ,member function, that checks whether a string ends with a specific substring.
Example of code using endswithmember function
What is output of this code?
Whats one useful operation that works with strings, lists, tuples and dictionaries?
‘in’ keyword
Whats ‘in’ keyword in Python?
checks whether one thing is in the object being checked.
What is output of the code?
Explain t why a certain condition fails to find b in the dictionary e.
if b in e:: Checks if the substring “World” is present as a key in the dictionary e. This condition fails to find “World” in the dictionary e because “World” is stored as a value, not a key. In e, “Hello” is a key, not “World”. Therefore, this condition evaluates to False, and no message is printed.
If we want to examine the values, we can simply ask the dictionary for a list of its values and check that instead . Like this:
The ‘not, ‘and’ and ‘or keywords modifies
the boolean to ask for the opposite thing.
The ‘not operator returns..
It returns True if the expression is False, and False if the expression is True.
The ‘and keyword - (2)
combines two expressions.
It returns True if both expressions are True, otherwise, it returns False
The ‘or keyword - (2)
The or keyword combines two expressions.
It returns True if at least one of the expressions is True, otherwise, it returns False.
we can write conditions that combine multiple requirements using
‘and’ and ‘or’ keywords in Python
What is the output?
You can chain together as many of ‘and and ‘or’ operators but
Be careful about which conditions will be combined in which order.
Parentheses can be used when writing multiple conditions to clarify to the
reader (esp writing multiple conditions using ‘and’, ‘or and ‘not’ in Python) even if if Python does not need them
Write a code that stores 5,10,15, 20 to variable a,b,c, and d respectively
Then check if a < 10 or b >10 and c< 25 or d < 25 and prints At least one of a/b are < 10 and at least one of c/d are < 25
Explain what the code does? - (4)
a = 5, b = 10, c = 15, and d = 20 are assigned initial values.
The if statement checks two conditions:
(a < 10) or (b < 10) checks if either a or b is less than 10.
(c < 25) or (d < 25) checks if either c or d is less than 25.
If both conditions are met, the message “At least one of a/b are < 10 and at least one of c/d are < 25” is printed
In this specific case, since a = 5 (which is less than 10) and d = 20 (which is less than 25), both conditions are met, so the message will be printed.
What is output of this code?
You can use single-character shorthand for
‘and’ , ‘or’, ‘not’ operators to achieve the same functionality
using single-character shorthand ‘and’ , ‘or’, ‘not’ operators to achieve the same functionality
e.g.,
or =
|
using single-character shorthand ‘and’ , ‘or’, ‘not’ operators to achieve the same functionality
e.g.,
and =
&
using single-character shorthand ‘and’ , ‘or’, ‘not’ operators to achieve the same functionality
e.g.,
not =
~
Example code of using using single-character shorthand ‘and’ , ‘or’, ‘not’ operators to achieve the same functionality
What is the output?
Question 1: String Formatting Issue
What is problem with code?
Use {} not [] to embed variables in f-strings
Question 2: Dictionary Key Error
The above code snippet attempts to print the location of the person. Identify the error and suggest a quick fix. In addition, suggest a general way to handle missing keys in a dictionary so that the code does not produce an error. - (3)
There is no key called ‘location’.
Probably ‘city’ is what you wanted.
Use the “get” function to try to access dict values by keys and return a None value rather than an error if the key is missing.
Question 3: While Loop Condition Error
Explain why the loop might not work as expected. How would you fix it to count down from 10 to 1. - (3)
The loop will never stop because the count is always <=10. There are lots of ways of fixing it. For example…
1: Add in an ‘and’ statement to the while loop (while (count<=10 and count >=1):
2: Just use a for loop with a range statement (for count in range(10,0,-1):
Question 4: Conditional Statement Syntax Error
Identify the syntax error in the conditional statements.
The last ‘else’ is missing a colon
else:
Question 5: Incorrect Use of the ‘is’ Operator
Explain why the is operator might not be appropriate in this context and suggest a correct approach. - (2)
‘is’ is usually used for lists or dictionaries or strings. For numbers, just use == instead
if (x>3) and (y==10):
Question 6: While loop and conditional
Describe the purpose of the else clause in this while loop and under what circumstances it is executed. - (2)
It is evaluated when the countdown gets to zero.
It tells the program what to do when the countdown is not 3,2,1…
Question 7: Rounding and mixing Data Types in F-String
How would you make this f-print statement round to the nearest integer? - (2)
Use the formatting string :something.0f following ‘score’ inside the first {}. The something part says how many figures to have in front of the decimal place, the ‘0’ part says to have nothing after the decimal place. For example
print(f”Your rounded score is {score:2.0f}, which is a {result}”)
name = “Emily”
age = 35
print(“My name is “ + name + “ and I am “ + age + “ years old.”)
What is the problem with this code? - (4)
The problem with this code is that the variable age is of integer type, and it cannot be directly concatenated with strings using the + operator.
To fix this, you should convert the age variable to a string using the str() function before concatenating it with other strings.
Here is corrected answer:
name = “Emily”
age = 35
print(“My name is “ + name + “ and I am “ + str(age) + “ years old.”)
numbers = [1, 2, 3, 4, 5]
print(numbers[6])
**Identify the error in the code and suggest a solution to avoid this error - (8)
Identify the error:
The error in the code is an “IndexError,” specifically stating that the index is out of range.
This means that the index 6 is beyond the bounds of the list numbers, which has indices ranging from 0 to 4.
Solution:
To avoid this error, ensure that the index used to access elements from the list is within the bounds of the list.
In this case, you should use an index that is valid for the given list.
For example, if you want to access the last element of the list, you can use index 4, not 6 e.g,, print(numbers[4])
Alternatively, you can handle such errors using try-except blocks to gracefully manage situations where an invalid index is used
Example of using try block for this example:
numbers = [1, 2, 3, 4, 5]
print(numbers[6])
def greet(name, message):
print(“Hello “ + name)
print(message)
greet(“Alex”)
Identify the syntax error in the function call and suggest a solution. - (5)
The syntax error occurs in the function call greet("Alex").
The function definition ‘greet()’ expects two arguments (name and message), but only one argument (name) is provided in the function call.
This results in a TypeError.
To fix this error, provide both name and message arguments in the function call, matching the expected arguments in the function definition.
Example solution:
greet(“Alex”, “Good morning!”)
Explain why the loop does not sum the numbers correctly and suggest a fix - (6)
total = 0
i = 1
while i <= 5:
total += i
print(“Total is:”, total)
The loop does not sum the numbers correctly because the loop control variable ‘i’ is never incremented inside the loop.
As a result, the loop condition while i <= 5 always remains true, leading to an infinite loop.
Consequently, the program keeps adding the same value of ‘i’ to ‘total’ repeatedly without progressing to the next number in the sequence.
To fix this issue, you should increment the value of ‘i’ inside the loop to ensure that it progresses through the numbers from 1 to 5.
By incrementing ‘i’, the loop iterates through each number in the sequence and correctly accumulates the sum of these numbers in ‘total’.
Example solution:
total = 0
i = 1
while i <= 5:
total += i
i += 1 # Increment ‘i’ inside the loop
print(“Total is:”, total)
What does ‘total+= i’ mean?
total = 0
i = 1
while i <= 5:
total += i
print(“Total is:”, total)
total += i is equivalent to total = total + i, which means the value of i is added to the current value of total, and the updated value is stored back in total.
my_list = [1, 2, 3, 4,]
print(my_list)
Identify the syntax error in the list initialization and suggest a fix - (2)
The trailing comma after the last element is unnecessary.
Remove it to avoid syntax errors.
Explain the following Python code - (2)
my_string = ‘ the cat Sat on The Mat. ‘
print(my_string.strip())
This code removes leading and trailing whitespace characters (such as spaces, tabs, and newline characters) from the string stored in the variable my_string.
The strip() method is used to perform this operation, and the resulting string with whitespace removed is printed to the console.
Explain the following Python code and how it combines string methods - (4)
my_string = ‘ the cat Sat on The Mat. ‘
print(my_string.strip().lower())
This code demonstrates the combination of string methods in Python.
First, the strip() method is applied to my_string to remove leading and trailing whitespace characters.
Then, the lower() method is applied to the resulting string, converting all characters to lowercase.
The combined effect of these methods is that the string is stripped of whitespace and converted to lowercase before being printed to the console.
Explain the meaning of the following string assignment (i.e., (i.e., “string assignment” refers to the process of assigning a string value to a variable) - (3)
my_string=”\n hello world \t”
In the given string assignment, my_string, the escape sequences \n and \t are used.
\n represents a newline character, causing the text “hello world” to start on a new line.
\t represents a tab character, adding tab spaces (equivalent to multiple spaces) before the text “hello world”.
Why might using a series of if statements to check for variations in capitalization or leading whitespace be considered clunky? - (2)
e.g.,
if (inputWord==’pencil’) or (inputWord==’PENCIL’) or (inputWord==’Pencil’) or (inputWord=…..
Using a series of if statements to check for variations in capitalization or leading whitespace can be considered clunky because it requires writing repetitive code and becomes cumbersome to maintain, especially if the password changes.
Also you may not think of all the variations people can type pencil
Let’s imagine we have a password system for school district
Each time someone wants to get in they have to type the password (‘pencil’). But, to make things easier, we don’t want it to fail if they have the CAPS LOCK key on, or if they are German And Need To Capitalize Lots Of Words. Or if they have accidentally added a space or tab at the start of the string (YNiC screensaver unlock box - I’m looking at you!).
Second way -Turning any user input to lower case and check against ‘pencil’ - produce this code - target string is ‘pencil’
target_string = ‘pencil’
user_input = input(‘Login with user password: ‘)
user_input = user_input.lower()
if user_input == target_string:
print(“Welcome to the Seattle Public School District DATANET”)
else:
print(“Password denied”)
Explain the following Python code - (6)
target_string = ‘pencil’
user_input = input(‘Login with user password: ‘)
user_input = user_input.lower()
if user_input == target_string:
print(“Welcome to the Seattle Public School District DATANET”)
else:
print(“Password denied”)
This code prompts the user to enter a password and compares it with a target password stored in lower case.
Firstly, the target password ‘pencil’ is stored as all lower-case characters in variable ‘target_string’
Then, the user is prompted to input their password.
The user_input.lower() function converts the user’s input to lower case, ensuring that the comparison is not case-sensitive.
If the user’s input matches the target password, ‘Welcome to the Seattle Public School District DATANET’ is printed; otherwise, ‘Password denied’ is printed.
This approach ensures that the password comparison ignores variations in capitalization and provides a robust password validation mechanism.
Explain the functionality of the split string member function .spilt() in Python.
The split string member function is designed to take a string and split it into a list of strings
What is the default behaviour of .spilt() string member function?
By default, it splits the string on any whitespace characters (such as spaces, tabs, or newlines/carriage-return characters),
Explain the functionality of the provided Python code - (10)
dat = ‘The cat sat on the mat’
res = dat.split()
print(type(res))
print(res)
print(len(res))
The provided code utilizes the split() method to split the string “The cat sat on the mat” into individual words.
It initializes a string variable dat with the value ‘The cat sat on the mat’.
The split() method is applied to dat, splitting the string into individual words based on whitespace characters.
The resulting list is stored in the variable res.
It prints the type of res (which confirms it’s a list), the contents of res (the individual words), and the length of res (the number of words in the original string).
Output:
<class ‘list’>
[‘The’, ‘cat’, ‘sat’, ‘on’, ‘the’, ‘mat’]
6
You can see that it takes the string “The cat sat on the mat” and breaks it apart into 6 strings - one for each part of the string between each space character.
The length of the resulting list is 6, corresponding to the number of words in the original string.
Explain how to change the character on which the split method splits a string in Python,
To change the character on which the split method splits a string, you can pass a desired ‘separator’ character as an argument to the method.
Example of change the character on which spilt spilts the string by passing our desired ‘seprator; character as an arguement - (2)
if we have a string which is separated by commas:
dat = ‘Person,Condition,RT’
res = dat.split(‘,’)
print(res)
Explain:
In this example, the string dat is split into individual parts at each comma character, and the resulting list is printed:
Output:
[‘Person’, ‘Condition’, ‘RT’]
Modify this code below to spilt on a different character like ‘o’:
dat = ‘Person,Condition,RT’
res = dat.split(‘,’)
print(res)
dat = ‘Person,Condition,RT’
res = dat.split(‘o’)
print(res)
What is output of this code:
dat = ‘Person,Condition,RT’
res = dat.split(‘o’)
print(res)
[‘Pers’, ‘n,C’, ‘nditi’, ‘n,RT’]
Explain this code - (5)
dat = ‘Person,Condition,RT’
res = dat.split(‘o’)
print(res)
The string ‘Person,Condition,RT’ is stored in the variable dat.
The split(‘o’) method is applied to dat, splitting the string at each occurrence of the letter ‘o’.
The resulting list is stored in the variable res.
It prints the content of res, which contains the parts of the string split at each occurrence of ‘o’.
So output would be: [‘Pers’, ‘n,C’, ‘nditi’, ‘n,RT’]
Explain the concept of “white-space” in Python and what it refers to - (2)
In Python, “white-space” refers to characters such as tabs, spaces, and newline/carriage-return characters.
These characters are used to format code or data files and are typically invisible when displayed.
What does “carriage return” mean in the context of datafiles? - (2)
n data files, “carriage return” indicates the end of a line in a datafile.
In Python, it is represented by the special symbol \n, which is interpreted as a “newline” character.
Example of using \n
What i the output of this code?
print(“Hello\nWorld”)
Hello
World
Explain this code and its output - (3)
print(“Hello\nWorld”)
The string “Hello\nWorld” is passed to the print() function.
You have inserted a newline in between the two words, so they get printed on different lines such as:
Output
Hello
World
What is a tab character in Python? - (2)
A tab character in Python, represented as \t, is a special type of whitespace character used to align text by moving the cursor to the next tab stop at a fixed interval.
It is commonly used for indentation and formatting purposes in documents, code, or data files.
What is output of code going to be?
print(“This\tis\tindented”)
This is indented
Explain the functionality of the provided Python code - (6)
my_string = ‘Country\t,GDP\t,Happiness\t,Authoritarianism\t\n\r’
string_list = my_string.split(“,”)
for thisString in string_list:
cleanString = thisString.strip()
print(cleanString)
This code initializes a string my_string containing tab-separated values (with commas as delimiters) and newline/carriage return characters.
The string is then split into a list of strings using the split() method with a comma delimiter.
Each element in the resulting list retains the tab characters (\t).
The for loop iterates over each element in string_list, and the strip() method is applied to remove any leading or trailing whitespace, including the tab characters, from each element.
Finally, it prints each cleaned string:
Country
GDP
Happiness
Authoritarianism
What is output of this code?
my_string = ‘Country\t,GDP\t,Happiness\t,Authoritarianism\t\n\r’
string_list = my_string.split(“,”)
for thisString in string_list:
cleanString = thisString.strip()
print(cleanString)
Country
GDP
Happiness
Authoritarianism
A full pathname for a file on a computer consists of a.. together these elements uniquelty identifiy - (2)
directory (or folder) and a filename, which must be unique within the directory.
Together, these elements uniquely identify the location of the file within the file system.
Explain the concepts of absolute and relative paths in computing
An absolute path provides the complete address of a file or directory starting from the root directory, whereas a relative path specifies the location of a file relative to the current working directory.
Provide an example of an absolute path in computing - (2)
An example of an absolute path in computing is
/home/user/documents/my_file.txt.
This path specifies the complete address of the file my_file.txt, starting from the root directory (/) and including all intermediate directories (home, user, documents).
Give an example of a relative path in computing - (3)
An example of a relative path in computing is data/my_data.csv.
This path specifies the location of the file my_data.csv relative to the current working directory.
It indicates that the file is located within a directory named data within the current working directory.
If a filename does not have a full directory component (i.e. it does not start with / or C: on Windows), it is said to be
relative.
Why is understanding absolute and relative paths important? - (2)
so that you understand where your program will look for files (when you are reading data in) and write files out (when you save data, figures etc out).
Understanding absolute and relative paths is important for determining where files will be located or saved when working with programs.
Explain the rationale behind using os.getcwd() in Python scripts. than %cwd? - (2)
os.getcwd() is preferred in Python scripts for retrieving the current working directory due to its portability and consistency across different environments.
Unlike %cwd, which is specific to Colab and may not work in other environments, os.getcwd() is a standard Python library function that works reliably across various platforms
What function can you use within a Python script to find the current working directory? - (2)
Within a Python script, you can use the os.getcwd() function to find the current working directory.
This function returns a string representing the current directory path.
How can you change the current working directory within a Python script? - (2)
You can change the current working directory within a Python script using the os.chdir(dirname) function, where dirname is a string containing the directory path to which you wish to change.
Before using os.getcwd() or os.chdir(dirname) and os.listdir(), we have to import module called
os
What does module os provide?
provides functions for interacting with the operating system.
Explain this code:
import os
print(os.getcwd()) - (3)
The code snippet imports the os module in Python, which provides functions for interacting with the operating system.
It then uses the os.getcwd() function to retrieve the current working directory.
The output of os.getcwd() will be the current directory in which the Python script is being executed.
Explain the functionality of os.listdir().
os.listdir() is a function in Python’s os module that returns contents , by default, of the current working directory
Why is it good to use abolsute file path names?
One reason is that if your programme crashes while you are in a different directory you might not be in the place you expect when you restart it.
If, when you are reading data, you are getting errors such as “No such file or directory”, it is probably because you are using a - (2)
relative file path and are not in the correct directory.
Or you have just typed the filename wrong.
What is the function used for joining parts of a file path together?
The function used for joining parts of a file path together is os.path.join.
Why is joining parts of a file together using os.path.join() useful?
This is particularly useful if we want to open many files from the same directory
In os.path.join () we can simply
pass it as many components of the path as we have, and it will join them in the correct manner.
Explain what does code does - (4)
from os.path import join
my_dir = ‘/content/sample_data/’
my_file = ‘mnist_test.csv’
my_filename = join(my_dir, my_file)
print(my_filename)
The code snippet demonstrates the usage of the join function from the os.path module which joins together directory and file names, creating full file paths (with separators appropriate to the file system you are on).
then defines a directory path (my_dir) and a file name (my_file).
Using os.path.join, it joins the directory path and file name to create a full file path to store in variable (my_filename).
It then prints my_filename which will be: /content/sample_data/mnist_test.csv
os.path.join() can also take a
string instead of a variable
What does the provided code snippet do? - (2)
my_filename2 = join(my_dir, ‘california_housing_test.csv’)
print(my_filename2)
The code snippet combines a directory path (my_dir) with a filename (‘california_housing_test.csv’) to create a full file path (my_filename2).
The resulting file path is then printed.
What is the output of this code?
my_filename2 = join(my_dir, ‘california_housing_test.csv’)
print(my_filename2)
/content/sample_data/california_housing_test.csv
You can also pass multiple individual dictionaries to to the join function e.g,
print(join(‘/home’,my_dir, ‘ynic’, ‘presentations’, ‘teaching’, ‘pin’,’file.txt’))
What does this code do? - (3)
from os.path import join
my_dir = ‘alex’
print(join(‘/home’,my_dir, ‘ynic’, ‘presentations’, ‘teaching’, ‘pin’,’file.txt’))
The code snippet showcases the usage of the join function from the os.path module to create a full directory path by joining together multiple individual directory names.
Starting from the root directory /home, it sequentially adds each directory name (‘alex’, ‘ynic’, ‘presentations’, ‘teaching’, ‘pin’) along with the filename ‘file.txt’.
The resulting full directory path is then printe
What is output of this code?
from os.path import join
my_dir = ‘alex’
print(join(‘/home’,my_dir, ‘ynic’, ‘presentations’, ‘teaching’, ‘pin’,’file.txt’))
/home/alex/ynic/presentations/teaching/pin/file.txt
What is the output of this code?
from os.path import join
base_path=’/home/pin/my_data/’
nSubjects=10 # Because what if we collect more subjects? All we have to do is change this
b=10
a=f’My favourite number is {b} ‘
print(a)
for thisSub in range(1,nSubjects+1): # The +1 is to make sure we go from 1 to 10 inclusive
fileName = f”S{thisSub:02}.txt”
print(join(base_path,fileName))
/home/pin/my_data/S01.txt
/home/pin/my_data/S02.txt
/home/pin/my_data/S03.txt
/home/pin/my_data/S04.txt
/home/pin/my_data/S05.txt
/home/pin/my_data/S06.txt
/home/pin/my_data/S07.txt
/home/pin/my_data/S08.txt
/home/pin/my_data/S09.txt
/home/pin/my_data/S10.txt
Comma-separated value (CSV) files are - (2)
plain-text files (meaning you can open them in a normal text editor and look at the data) where data items are separated by commas and where new sets of fields are placed on different lines (by means of a new-line character).
They are easy to understand.
Example of CSV files
Wade,Alex,49
Smith,Joe,21
Doe,Jane, 23
West,Mae,29
CSV files are common and can be
exported from spreadsheet software and are easy to read and write in just about all programming languages.
What does the CSV module in Python facilitate? - (2)
The CSV module in Python facilitates the reading and writing of data from and to CSV (Comma-Separated Value) files.
It provides functions specifically designed to handle CSV file operations efficiently.
How to import CSV module in python?
Type:
import csv
What are the 3 modules that have in built CSV readers?
- Pandas
- Numpy
- Python CSV module
Explain this code - (6) that opens the entire CSV file
import csv: Imports the CSV module, allowing us to work with CSV files.
- ##
with open('/content/sample_data/california_housing_test.csv', 'r') as csvfile:: Opens the CSV file in read mode (‘r’). The file path is provided in absolute format. -
reader = csv.reader(csvfile, delimiter=','): Creates a CSV reader object namedreader. - The
delimiter=','argument specifies that fields in the CSV file are separated by commas. -
for row in reader:: Iterates through each row in the CSV file -
print(', '.join(row)): Joins the items in the current row with commas and prints them
What is PANDAS?
a Python module designed for reading in and processing data tables, it introduces a new data type called DataFrame
Pandas is the most common and easiest way to
load in and process .CSV files
Example of reading in csv folder in pandas:
How about the average?
Explain this code - (3):
import pandas as pd
housingTable=pd.read_csv(‘/content/sample_data/california_housing_test.csv’)
housingTable.latitude
averageLatitude=housingTable.latitude.mean()
print(f’Mean latitude={averageLatitude:3.3f}’)
This Python code imports the Pandas library as ‘pd’ and reads a CSV file named ‘california_housing_test.csv’ located in the ‘/content/sample_data/’ directory.
The data from the CSV file is loaded into a Pandas DataFrame named ‘housingTable’.
Then, it calculates the mean latitude from the ‘latitude’ column of the DataFrame using the mean() function and prints it with 3 minium width (of entire string) and to 3 DP
You can also convert dataframe (pandas) to something you are comfortable with like - (3)
a list
e.g., import pandas as pd
housingTable=pd.read_csv(‘/content/sample_data/california_housing_test.csv’)
housingList = housingTable.values.tolist()
How about the average?
Explain what this code does - (6)
import pandas as pd
housingTable=pd.read_csv(‘/content/sample_data/california_housing_test.csv’)
housingTable.latitude
print(f’Mean lat: {housingTable.latitude.mean():3.3f}’)
housingList = housingTable.values.tolist()
latitude=housingTable[‘latitude’].tolist()
The code imports the Pandas library under the alias pd.
It reads a CSV file named california_housing_test.csv located in the specified path /content/sample_data/ into a Pandas DataFrame named housingTable.
It accesses the latitude column of the housingTable DataFrame.
It calculates the mean of the latitude column using the mean() method and prints it with prints it with 3 minium width (entire string) and to three decimal places.
It converts the DataFrame housingTable into a list of lists using the values.tolist() method and stores it in housingList.
It extracts all values from the latitude column of the housingTable DataFrame and converts them into a list stored in the variable latitude.
import pandas as pd
data = pd.read_csv(“/content/sample_data/california_housing_test.csv”)
print(data.head())
This code aims to read a CSV file using pandas.
What is the purpose of the head() method, and why is it used in this context? - (2)
The purpose of the head() method in pandas is to display the first few rows of the DataFrame.
It provides a quick overview of the data structure and its contents, helping users understand the data better.
Q1:
import pandas as pd
df = pd.read_csv(“content/sample_data/california_housing_test.csv”)
print(df.head())
Something is wrong with the following code. Explain what is wrong - and why.
The path name is missing a leading slash to indicate that it starts at the root.
To convert from celsius to fahrenheit you multiply by 9/5 and add 32. What is wrong with the following code? How might you fix it?
Note - there are two potential issues here - try to make the conversion as accurate as possible. - (2)
First, the list is made of strings but you are trying to multiply them by a number.
Second, you append ‘C’ not ‘F’ to the list so you never store the Fahrenheit value –> So, The code indeed appends the original Celsius value (C) to the list instead of the calculated Fahrenheit value (F), so it doesn’t store the converted Fahrenheit temperatures.
Password hell. What is the matter with this code?
The input statement is not in the loop so if you get it wrong once, you enter an infinite loop.
s = “Python_Data_Science”
words = s.split(‘-‘)
print(words)
I’m trying to split the string ‘s’ into individual words. What is going wrong?
It’s splitting on a hyphen (-) but the string has underscores in it (_)
Q3.5
I’m trying to read in a file using the Python csv reader. I think I almost have it but it doesn’t quite work…
Can you see what is wrong?
You should parse each row in csv_reader. csv_file does not exist
Broadly, what are the two types of errors in programming? - (2)
- Errors that stop you running the code (‘syntax errors’) - These are often easy to spot. These days the editor will usually show you where they are.
- Errors that happen while you are running the code - These are the ones that keep you up at night. Some of them crash the programme. That is good! The other ones just do the wrong thing but don’t throw an error. That is bad! -runtime errors
Provide an example of syntax error - (2)
print(‘Welcome to the programming course!)
Unterminated string literal
Example of an error that only pops up when you are running your code - (3)
myNum = int(input(‘Enter a number’))
Giving input as string instead of a number
Running this code will produce an ValueError exeception as Python does not know what ‘ten’ is
What is ValueError exception in Python?
A ValueError exception occurs in Python when a function expects a certain type of input, such as a string or a number, but the actual value provided is not valid or appropriate for that type.
What is an exception?
An error that occurs while the code is running.
What does a traceback in Python indicate? - (2)
traceback in Python indicates that an exception has occurred during the program’s execution.
It provides information about where the exception happened in the code, often marked by a little arrow or a message like ‘An error occurred on line xx’.
The exact line number in your traceback may differ depending on how you have structured your script, but the
message will be similar.
What does the error message “Invalid literal for int() with base 10” mean? - (2)
This error message indicates that Python attempted to convert a string into an integer (of base 10 – normal decimal numbers), but the string doesn’t resemble a number.
This is not something which can be done, so Python raises an ValueError exception
Describe in more detail about the try and except blocks
try means that we will attempt the code within the block and, if an exception is found, we will move to the except block (or blocks).
Describe the purpose of the try-except block in the provided example - (2)
The try-except block attempts to convert user input into an integer.
If a ValueError exception occurs (if the input is not a number), the except block handles it by printing a message and the exception itself (e is returned as the exception)
What is the output of this code - if input is ‘hi’
Note when an exception is caught and handled using a try-except block, we do not get a - (2)
Note that we no longer get a full traceback.
Instead, it executes the code in the except block, which typically includes a message and the error message itself (ValueError exception) and the programme stops but critically it does not crash.
How to extend this code in which we should just ask again until the user gives us something sensible.
You can use try and except blocks if you suspect code may
crash
What is output of the code if i my input is hi then hi then 9?
How can you handle multiple potential errors using except blocks in Python?
You can handle multiple potential errors by including multiple except blocks, each corresponding to a specific type of error.
Explain this code - (8)
This code prompts the user to input a number to calculate its reciprocal. It begins by setting recip to None, indicating that no valid reciprocal has been calculated yet.
The while loop continues until a valid reciprocal is calculated.
Within the loop, the try block attempts to convert the user input into an integer and calculate the reciprocal.
If the user provides a non-integer input (e.g., a string), a ValueError is raised, and the program prints “Please enter a valid integer.” The program then re-prompts the user for input.
If the user attempts to divide by zero, a ZeroDivisionError is raised, and the program prints “Cannot divide by zero. Please enter a non-zero number.”
Only when the user provides a valid integer input will the code proceed to attempt the calculation of the reciprocal.
Once a valid non-zero integer is entered, the reciprocal is calculated, and the loop exits.
Finally, the calculated reciprocal is displayed with three decimal places using f-string formatting.
What is output of the code if i give 0,0 then ten?
Explain what happens to the code when i give 0 as input? - (5)
You input 0 when prompted.
The program attempts to calculate the reciprocal, which is 1 divided by the input number (0).
Division by zero occurs, triggering the ZeroDivisionError.
The program executes the corresponding except ZeroDivisionError block, printing “Cannot divide by zero. Please enter a non-zero number.”
The loop continues, prompting you to input another number.
Until you input a non-zero number, the program will keep repeating this process, not proceeding to calculate the reciprocal until valid input is provided.
Explain what happens to the code if give ‘ten’ (as string) as user input? - (6)
You input ‘ten’ when prompted.
The program attempts to convert the input into an integer using int(‘ten’).
Since ‘ten’ cannot be converted into an integer, a ValueError occurs.
The program executes the corresponding except ValueError block, printing “Please enter a valid integer.”
The loop continues, prompting you to input another number.
Until you input a valid integer, the program will keep repeating this process, not proceeding to calculate the reciprocal until valid input is provided.
What happens if the try block fails in the provided code?
If the try block fails, the variable recip will remain as ‘None’, as indicated by the comment: “# Here is the place where we try to get an input. Note that if it fails, start will stay as ‘None’.”
What are functions? - (3)
Functions are bits of code that take arguments (parameters), perform operations with them, and optionally return values.
unctions allow code to be written and reused cleanly.
Once a function is defined for a specific task, it can be used multiple times throughout the program.
Can funcions be changed together?
Yes e.g.,, print(list(range(5)))
Explain the code (example of chaining functions together):
print(list(range(5))) - (3)
In the example given, the return value from the range() function is passed to list() which casts the return value from range() into a list.
Subsequently, the resulting list is passed as an argument to the print() function, which then prints the list.
In each case, the return value from the innermost function becomes the argument to the next function.
Functions in Python can return multiple values either as a
tuple (single variable) or break them out into separate variables:
Provide an example of a function that returns multiple values.
divmod() function,
What does divmod () function return?
returns the integer division of a number as well as its modulus (remaineder) when an integer is divided by another integer
For example,
whatt would divmod (5,2) return?
we will get the numbers 2 (integer division), remainder 1.
For divmod(5, 2), we will get the numbers 2 (integer division), remainder 1. We can either - (2)
take these return values into a single variable as a tupe
or expand the values out into multiple variables
Example of just printing the return value of divmod
print(divmod(5, 2))
Example of sttoring the return value of divmod(5,2) into a single variable
Code:
ret = divmod(5,2)
print(“ret is “, ret)
Output
ret is (2,1)
Example of storing return value of divmod(5,2) into 2 variables:
Code:
d,r = divmod(5,2)
print(“d is:”, d)
print(“r is:”, r)
Output
d is : 2
r is: 1
Describe the purpose of the code: d, r = divmod(5, 2) - (2)
The function returns a tuple containing two values: the he integer division (quotient) and the remainder from integer division of integer 5 divided by integer 2 which is 2,1
These returned values are directly assigned to the variables d and r, respectively, and then printed.
Explain what the following code does: ret = divmod(5, 2). - (2)
his code calls the divmod() function with arguments 5 and 2, which returns a tuple containing the quotient (integer division) and the remainder of dividing 5 by 2.
Returns these two values into a tuple and then stored into variable called ‘ret’
What are the two types of functions? - (2)
- ‘Standalone’ functions
- ‘Member’ functions
What are ‘standalone’ functions?
functions that take all of their arguments in the parameters.
Example of ‘standalone’ functions
range, type and print.
What are ‘Member’ functions, and why are they called that?
Member’ functions are functions that are “bound” to a specific object.
Why are ‘member’ functions called ‘member’ functions? - (2)
They are called ‘Member’ functions because they are part of the object (i.e., variable) on which they are called,
e.g., or instance, .append() is automatically part of any list variable which you create
How can you see all the member functions of an object in Python?
You can use the dir() function, passing the object (i.e., variable) as an argument.
Explain the purpose of the code:
my_var = [1, 2, 3]
print(dir(my_var)).
This code initializes a list variable my_var with values [1, 2, 3], and then uses the dir() function to display all the member functions associated with the list object my_var
Explain the output of this code - what do underscores
my_var = [1, 2, 3]
print(dir(my_var))
In addition to the ‘private methods’ (indicated with underscores - we are not supposed to use them), we can see our old friend append - along with other methods which we talked about including index and pop.
Structure of member funciton
VARIABLENAME.FUNCTIONAME()
TThe idea of a member function is tha it will affect the variable it is a part of so append will
cause the list to have additional items added to it
What is the difference between normal and member functions? - (4)
When you call normal functions don’t need to specifcy the data structure - They are called by specifying the function name followed by parentheses and passing arguments inside the parentheses.
With member funcions, you mustt provide the data structure and they operate on the data contained within that object.
n Python, for example, when we call append() on a list (my_list.append(4)), append() is a member function because it operates specifically on the list object my_list and modifies it directly.
However, when we call print(my_list), print() is a normal function because it’s a built-in function that is not associated with any specific object.
Many Python editors will help you out by ‘prompting’ you with possible member functions when you are writing code. For example, after defining a = [1,2,3,4….1]
writing a. , Colab will provide a little ‘menu’ of all the member functions (purple boxes) avaliable to you - can do this instead of using dir
Python has a concept of collections of functions which are called
modules
Describe the purpose of the random module in Python - (2)
The random module in Python is part of the standard library and provides functions for working with random numbers.
It offers various functionalities for generating random numbers, shuffling sequences, and many more
Explain the process of importing modules in Python and accessing their content - (2)
To use a module in Python, you first need to import it using the import keyword.
In environments like Spyder, iPython3, and Colab, after importing a module, you can type the module name followed by a dot (.) and then press the tab key (or wait) to get a list of available content within that module.
What does this code do? - (2)
import random
print(dir(random))
First, the random module is imported using the import keyword
Then, the dir() function is used on random module to list all its associated functions and is outputted using print()
Output of this code
import random
print(dir(random)
is shuffle one of the functions in random module?
Yes
What is the shuffle function in random module used?
This function is used to randomise the order of a list -
Why is shuffle important? - (2)
We do this in experiments quite a bit:
For example, when putting stimuli on a screen it’s often important to randomise the order so that the subject can’t tell what is coming next
Explain the code snippet - (5)
After importing the random module, a list a containing integers [1, 2, 3, 4] is defined. T
The original order of the list is printed using the print() function.
Next, the shuffle() function is called on the list a, which randomizes the order of its elements in the list.
The shuffled list is printed using the print() function to display the new order.
Finally, the shuffle() function is called again on the same list a, further randomizing its order of elements in that list, and the shuffled list is printed once more.
What would be the possible output of this code snippet?
How to produce a list storing in variable a from values 0 to 100 inclusive.
a = list(range(101)
We call the function as random.shuffle because we
imported the shuffle module using import random and the function is “inside” the module.
Describe the purpose and behavior of the randint() function in the random module - (3)
he randint() function in the random module generates a random integer between two specified numbers.
It takes two arguments representing the lower and upper bounds of the range, inclusively.
When called, randint() returns a random integer within this range.
Explain how random.randint() is used to generate random integers between 1 and 5 inclusively in the provided code snippet - (3)
In the code snippet, the random.randint() function is called multiple times, each time with arguments (1, 5).
This specifies the range from which the random integer should be generated, starting from 1 and ending at 5, inclusive.
Therefore, each call to random.randint(1, 5) produces a random integer between 1 and 5, with the possibility of including both endpoints.
While both shuffle() and randint() are functions in the random module, they serve different purposes. - (2)
shuffle() rearranges the elements of a list in a random order, effectively shuffling its contents.
randint() generates a single random integer within a specified range, inclusive of both endpoints.
Describe how to create a loop to generate 100 random numbers between 1 and 10 using Python - (4)
To achieve this, import the random module.
Then, utilize a for loop to iterate 100 times using the range() function.
Within the loop, call random.randint(1, 10) to generate a random integer between 1 and 10 on each iteration and store into variable random_num
Print each generated number to output console by printing random_num
How to import numpy?
Using the same method as before we did with random
What is numpy module in Python?
a module for processing numbers.
To avoid some typing, we can use a feature in Python ‘as’ keyword which allows us to rename the module as we imprt it:
import numpy as np # This is always how people name numpy when they import it.
print(dir(np))
Describe the advantages of using aliases when importing modules in Python. - (2)
Importing modules with aliases, such as import numpy as np, offers several benefits.
It reduces typing effort, enhances code readability by shortening module names, and promotes cleaner code appearance.
By using the import MODULE as SHORTNAME variant, we
import numpy in exactly the same way as before, but we make its contents available as np.SOMETHING instead of numpy.SOMETHING.
Importing numpy as ‘np’ has also become the common
convention in most scientific code.
We should note that modules can have modules within them - (2)
e.g.,
Numpy module has a random module called numpy.random
Distinct from main Python random module and has different functions inside it e.g,:
What does as keyword do in Python?
It’s commonly used in import statements to provide an alternative name for a module or to shorten the module name for brevity and readability.
Explain this code - (2)
The code imports the NumPy library as np (using ‘as’ keyword) and then prints the contents of the numpy.random submodule using the dir() function.
This allows users to explore the available functions and attributes within the numpy.random submodule.
One other form of import which you may come across is used if you only want a - (2)
few functions or classes from a module and would rather that they have short names
e.g., from numpy import zeros, ones
Explain the code snippet - (3)
This code snippet imports the zeros and ones functions from the numpy module.
The print(type(zeros)) line confirms that the zeros function has been imported, displaying its type as <class ‘function’>.
Finally, print(zeros(10)) calls the zeros function to create an array of size 10 filled with zeros, which is then printed to the console.
What is the output of this code?
What do the zeros and ones functions do?
These functions, imported from the numpy module, create arrays filled with zeros and ones respectively.
Produce a code that prints out of one-dimensional array of ones with size 10 - (2)
from numpy import zeros, ones
print(ones(10))
What is going to be the output of this code?
from numpy import zeros, ones
print(ones(10))
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
Explain the code snippet. - (3)
he code imports the zeros and ones functions from the NumPy module.
Then, it prints a 1-D array of ones with length 10 using ones(10).
Additionally, it prints a 2-D array of ones with dimensions 10x10 using ones((10,10)).
Arrays can be
1D or 2D or 3D
What is output of this code snippet?
When we import it in this way:
e.g., from numpy import zeros, ones
we just use the names that we import without any module name prefixing.
When do I import things? - (2)
Import modules **at the top of your script, not halfway through it.
Putting imports at the top of your script allows the reader to get an idea of what sort of functionality will be used and is considered good practice.
What would print(ones((10,10,10))) print to output console/terminal? - (2)
be a 3D array filled with ones, with dimensions 10x10x10. Each element of the array would be a 1.
10 lots of these: (image)
You can also produce your own functions using
def
What is the syntax for defining a function in Python? - (2)
In Python, the syntax for defining a function involves using the def keyword followed by the function name and parentheses containing any parameters.
The body of the function is indented and contains the code to be executed.
Explain this code - (5)
defines a function named printNTimes that takes two parameters: my_string, which represents the string to be printed, and n, which represents the number of times the string should be printed.
Inside the function, a for loop iterates over the range from 0 to n-1.
During each iteration, the value of my_string is printed to the console.
So, when you call this function with a string and a number n, it will print the string n times.
However, this function been defined but have not called printNTimes function so there is no output
What is the output of this code?
(Nothing)
Why is the output nothing when you run the code? - (3)
No output appears because the function printNTimes is defined but not called with specific arguments.
To execute its instructions, you need to call the function with a string (my_string) and a number (n).
e.g., printNTimes(‘hello world’ ,9)
This function takes two arguements (my_string, n) which you must supply otherwise
the function will fail- TypeError
What happens when you try to call the function printNTimes() without any arguments?
Calling the function printNTimes() without providing the required arguments (my_string and n) will result in a TypeError because the function expects two arguments but none were provided.
What is the output if we call function printNTimes: printNTimes (‘:)’,5)
Def functions are useful for
doing things again and again without replicating code for
Functions do things (i.e., execute tasks/code) and they also (usually) ‘return’
one or more values
Example of def function returning values
Explain the code and its output - (3)
def square(x):
y=x*x
return(y)
answer=square(5)
print(answer)
The square function takes an argument x and calculates the square of this input number.
It stores the result in the variable y and returns it. In the code snippet, square(5) is called, computing the square of 5, resulting in 25.
This value is stored in the variable answer, which is then printed, producing the output: 25.
What does the code print(‘#’*n) accomplish, given n=100?
It prints 100 hashtags in a row.
Explain the purpose of the def function: def print_underline(inputString,underlineCharacter)
This function, print_underline, takes two arguments: inputString and underlineCharacter.
It calculates the length of inputString using the len() function and stores it in the variable stringLength.
Then, it prints inputString, followed by an underline made of underlineCharacter repeated for the length of inputString.
Finally, it returns the length of the inputString
What would be output if print_underline was given inputString as ‘Hello World’ and underlineCharacter of ‘#’ and then:
my_value = print_underline(‘Hello World’, ‘#’)
print(f’Length is {my_value}’)
Hello World
###########
Length is 11
For larger scale data analysis (usually with neuroimagning data) we can use pre-existing modules and core tool for this in Python is
numpy
Numpy works with
large blocks of numbers called ‘matrices’ (or sometimes ‘arrays’)
Matrices are often rectangular blocks that are
stored as rows x columns
Matrices are often rectangular blocks that are stored as rows x columns.
For instance:
3 rows by 2 columns so it would have shape (3, 2).
The order of the dimensions of matrices is always
(rows, columns).
For most of the time we will be working with 2D matrices, however numpy will cope with any number of dimension from
(from 1D up to any number of dimensions).
Matrices are usually two-dimensional whereas arrays can be
have any number of dimensions
when performing addition, subtraction, multiplication, or division on matrices, they must be of
he same size, meaning they must have the same number of rows and columns.
Example of addition of matrices
Example of subtraction of matrices:
Example of multiplication and division of matrices - element by element mulplication/division|
matplotlib is a
plotting library that lets you produce a range of different graphs
Explain the code please - (5)
import numpy as np: This line imports the NumPy library and aliases it as np, allowing us to refer to NumPy functions and objects using the shorter name np.
z = np.zeros((2, 3)): This line creates a 2x3 matrix filled with zeros.
The numbers (2, 3) inside the parentheses represent the dimensions of the matrix, with 2 rows and 3 columns.
print(‘Here is an array of zeros’): This line prints a descriptive message to indicate that the following array contains all zeros.
print(z): This line prints the array z containing zeros to the console.
What is the output of the code?
Here is an array of zeros
[[0. 0. 0.]
[0. 0. 0.]]
What does z[0, 0] = 1.0 do? - (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets the element at the first row and first column of the matrix z to 1.0.
In other words, it modifies the top-left element of the matrix.
What does z[0, :] = 2.0 - (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets all elements in the first row (all columns) of the matrix z to 2.0.
It fills the entire first row with the value 2.0.
What does z[:, 1] = 3.0- (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets all elements in the second column (all rows) of the matrix z to 3.0.
It fills the entire second column with the value 3.0.
What does z[0, :] = 2.0 - (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets all elements in the first row (all columns) of the matrix z to 2.0.
It fills the entire first row with the value 2.0.
What does z[:, 1] = 3.0- (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets all elements in the second column (all rows) of the matrix z to 3.0.
It fills the entire second column with the value 3.0.
What is the output of this code?
import numpy as np
z = np.zeros((2, 3)) # The size thing here is a tuple - it can also be a list
print(‘Here is an array of zeros’)
print(z) #array of 2x3 zeros
print(‘Now I set the bottom right element (1,2) to 9’)
z[1,2]=9 #Work out how to do this
print(z [1,:])
What does the comment mean: # The size thing here is a tuple - it can also be a list - (4)
refers to the argument passed to np.zeros(), which specifies the dimensions of the array.
In Python, dimensions are often represented as tuples, where the first element indicates the number of rows and the second element indicates the number of columns.
However, this argument could also be provided as a list.
Explain what this code does - (3)
his code imports the NumPy library with the alias np
a 3x4 matrix filled with ones using the np.ones function and stores it in the variable o.
Finally, it prints the contents of the o matrix to the output console.
What is the output of this code?
Explain this code - (3)
This code imports the NumPy library as np and creates a 2x4 NumPy array named “a” by converting a list of lists into an array.
The array contains the elements [[1, 2, 3, 8], [4, 5, 6, 9]].
Finally, it prints out the array “a”.
What is the output of this code?
Explain thsi code - (4)
This code initializes a NumPy array a with integer values in a 2x3 format, meaning it has 2 rows and 3 columns.
Then, it uses the astype method to explicitly cast the data type of the array a to float.
This operation overrides the original array a and changes its data type from integer to float.
Finally, it prints the modified array a, now containing floating-point values.
Explain this code - (4)
This code initializes a NumPy array a with values in a 2x3 format.
It specifies the data type of the array as int, which forces all elements to be integers, even if they were floats initially.
This is achieved using the dtype=int parameter in the np.array function call.
Finally, it prints the resulting array a.
What is output of the code going to be - going to be same even if its 3.6 instead of 3.6
Example of converting list to numpy array
What will be output of the code?
Explain this code - (4):
This code first imports the NumPy library and then defines a list of numbers (my_numbers) containing two sub-lists.
Next, it converts the list my_numbers into a NumPy array using the np.array() function which is stored in variable ‘a’
The resulting array a is a 2D array with the same structure as the original list and a size of 2x3 (2 rows and 3 columns).
Finally, it prints the array a,
Explain this code - (3)
In the first example (a = np.arange(3)), it creates an array containing numbers from 0 up to (but not including) 3.
In the second example (b = np.arange(1, 3)), it creates an array containing numbers from 1 up to (but not including) 3.
In the third example (c = np.arange(1, 3, 0.5)), it creates an array containing numbers from 1 up to (but not including) 3, with a step size of 0.5,
What would be the output of this code?
Explain the code snippet (output attached) - (4)
This code snippet first imports the matplotlib.pyplot module and the numpy module as plt and np,
respectively.
It then generates an array of ‘x’ values from 1 to 5 with a step size of 1 using np.arange(1, 6, 1).
Next, it calculates ‘y’ values by squaring each ‘x’ value.
Finally, it plots the data with ‘x’ values on the x-axis and ‘y’ values on the y-axis using plt.plot() and displays the plot using plt.show().
Modify the code below to plot a nice smooth cubic function (x to the power of 3) between -5 and 5 with exactly 100 steps:
Explain this code - (4)
This code snippet imports the matplotlib.pyplot module and the numpy module as plt and np, respectively.
It then generates an array x containing 100 equally spaced numbers between -5 and 6 using np.linspace(-5, 6, 100).
Next, it calculates ‘y’ values by cubing each ‘x’ value.
Finally, it plots the data with ‘x’ values on the x-axis and ‘y’ values on the y-axis using plt.plot(), adds gridlines to the plot using plt.grid(True), and displays the plot using plt.show().
Output of 1D array vs 2D array:
What does the following code snippet do? - (2)
import numpy as np
r = np.random.rand(2, 2)
print(r)
This code snippet uses np.random.rand() to generate a 2D array r with 2 rows and 2 columns, filled with random numbers between 0 and 1.
It then prints the generated array r
All of the generated numbers here lie between 0 and 1 (as well as colour bar runs from 0 to1)
Each number is equally likely to be chosen - we say that the distribution is ‘uniform’.
Explain this code snippet - (4)
This code snippet generates a 50x50 array of random numbers drawn from a normal distribution using np.random.randn().
It then displays the array rn as an image using plt.imshow(), with colors representing the values of the numbers.
Additionally, it adds a color bar to the side of the plot using plt.colorbar(), which helps interpret the colors.
Finally, it displays the plot using plt.show().
Explain this code - (4)
This code snippet generates a 20x20 array of random numbers between 0 and 1 using np.random.rand().
It then displays the array r as an image using plt.imshow(), with colors representing the values of the numbers (When displaying numerical data as an image, each numerical value in the array is mapped to a color)
Additionally, it adds a color bar to the side of the plot using plt.colorbar(), which helps interpret the colors.
Finally, it displays the plot using plt.show().
Explain this code - (3) - assuming previous code of defining ‘r’ and ‘rn’ and producing their graphs
fig,a = plt.subplots(1,2)
fig,a = plt.subplots(1,2)
a[0].imshow(rn) #This function shows your normal-random array as an image
a[1].imshow(r) #This function shows your uniform-random array as an image
fig, a = plt.subplots(1, 2): This line creates a figure with two subplots arranged side by side. The subplots() function returns a figure (fig) and an array of axes (a). In this case, 1 indicates that there is only one row of subplots, and 2 indicates that there are two subplots in total (side by side).
a[0].imshow(rn): This line displays the first subplot (a[0]) and shows the normal-random array rn as an image using the imshow() function. a[0] refers to the first subplot created by plt.subplots(), and imshow() is a function used to display arrays as images.
a[1].imshow(r): This line displays the second subplot (a[1]) and shows the uniform-random array r as an image using the imshow() function. a[1] refers to the second subplot created by plt.subplots().
Explain this code - (5)
This code snippet assumes that rn and r have been defined previously as arrays representing different types of random numbers.
It creates a figure with two subplots arranged side by side using plt.subplots(1, 2).
In the first subplot (a[0]), it computes and displays a histogram of all numbers in the array rn after flattening it into a 1D list using flatten(). The histogram is computed with 50 bins.
In the second subplot (a[1]), it computes and displays a histogram of all numbers in the array r. Similar to the first subplot, the histogram is computed with 50 bins.
This allows for a visual comparison of the distributions of two arrays, which may represent different types of random numbers.
What will be output of the code?
import numpy as np
a=np.array([[1,2],[3,4]])
b=np.array([[5,6],[7,8]])
c=a+b # Adding two arrays which are the same size
d=a*10 # Multiplying a single array by a scalar
print(a)
print(b)
print(c)
print(d)
What does the following code snippet do? - (3)
a_mean = a.mean()
print(a_mean)
a_sd = a.std()
print(a_sd)
a_var = a.var()
print(a_var)
a_mean = a.mean() calculates the mean (average) of the numbers in array ‘a’ and assigns it to the variable ‘a_mean’. The mean is then printed.
a_sd = a.std() computes the sample standard deviation of the numbers in array ‘a’ and assigns it to the variable ‘a_sd’. The standard deviation is then printed.
a_var = a.var() determines the sample variance of the numbers in array ‘a’ and assigns it to the variable ‘a_var’. The variance is then printed.
When double clicking on polygon, these properities show up - (basic) - (3)
It is asking you to name the polygon stimuli in trial routine so far it is set as ‘polygon’
Asking for start and end time
The shape of the polygon is going to a triangle but can alter it at the drop down menu
You can also choose a hexagon in polygon properities box by
from shape menu select regular polygon with 6 sides - making it a hexagon
“In PsychoPy, if both text and polygon stimuli have the same duration, what determines their order of appearance?” - (2)
“The order in which stimuli are stacked in the routine determines their presentation order.
Since both text and polygon stimuli have the same duration value (1.0), the polygon stimulus will appear ontop of the text stimulus
If we run the experiment with this
polygon appears over the text and since polygon is so big, we can’t see the text
What does the appearence section of polygon properities box show you? - (5)
Fill colour: The colour with which the polygon is filled.
Border colour: The colour of the polygon’s border.
Colour space format for the specified colours.
Opacity of the stimulus: A value of 1 indicates it’s opaque, 0 means fully transparent, and 0.5 represents translucency.
Contrast of the stimulus and width of the shape.”
Fiddle with RGB colours so polygon is black ([-1,-1,-1])
Can fiddle with RGB colours to make it white by
setting to [1,1,1]
How can we make the polygon move? - (4)
“To make a polygon move continuously across the screen:
Go to the polygon properties and click on its ‘layout’ tab.
Find the ‘position’ entry.
Replace the X-coordinate with ‘t,’ representing the current time since the start of the experiment in seconds.
Set the menu setting to the right of the Position to ‘set every frame’ to ensure the position updates on every frame.”
What is variable ‘t’ in Psychopy? - (2)
the current time since the start of the experiment in seconds.
That number is always getting bigger.
What happens when we replce the ‘x’ coordinate of position with t? - (3)
tell Psychopy to update the position of polygon on every frame then the polygon will move across the screen:
causes the stimulus to move horizontally across the screen over time.
This is because ‘t’ represents the current time since the start of the experiment in seconds, and it continuously increases as the experiment progresses.”
How to make the polygon move to the left? - (3)
Replace the ‘x’ coordinate of the position with ‘-t’. This means that the position along the x-axis will decrease as time increases, effectively moving the polygon to the left.
Psychopy needs to update the position on every frame to ensure continuous movement.
To do this, change the menu setting next to the position property to ‘set every frame’.”
What does replacing ‘t’ in x coordinate of position with sin(t * 2 * pi
As ‘t’ time gets bigger, polygon goes up and down (along horizontal axis) like a sine wave
How to make the polygon rotate in the centre? - (5)
Make the orientation of the object dependent on time (instead of position)
Set position to 0,0 (x,y) at the centre
The orientation is set by degrees
So after 1s , move 1 degree and after 2s move 2 degrees which is not fast if orientation set to just ‘t’
So to make polygon spin faster, we can set ‘t’ to 20 so after 1 s, orientation of polygion moves by 20 degrees, after 2s orientation of polygon moves by 40 degrees etc..
Ensure orientation is updated on every frame by setting the menu setting next to the orientation parameter to ‘set every frame’.”
To make polygon randomly move to the left, right or stay in the middle - (8)
Start by adding a code component to your PsychoPy Builder project. This component allows you to insert custom Python code into your experiment.
Inside the code component, navigate to the ‘Begin Routine’ tab. Here, you’ll write code that will be executed at the beginning of each trial or routine.
In the ‘Begin Routine’ tab, insert the following Python code:
direc = randint(-1, 2)
This code utilizes NumPy’s randint function to generate a random integer between -1 (inclusive) and 2 (upper range exclusive) so:
The possible values for direc will be -1, 0, or 1.
This variable direc will determine the direction of movement for the polygon.
Set the polygon’s position parameter to (t * direc, 0), where t represents time. Multiplying t by direc allows for random movement along the x-axis. If direc is -1, the polygon will move left; if direc is 0, it will stay in the middle; if direc is 1, it will move right.
To ensure that the position is updated on every frame, set the menu setting next to the position parameter to ‘set every frame.’ This ensures that the polygon’s position is continuously updated throughout the duration of the routine, allowing for dynamic movement.”
“If we set the position of the polygon to (t * direc, 0) but set it to constant - (5)
The polygon’s position is determined by ‘t’ multiplied by ‘direc’ (-1, 0, or 1).
At the beginning of the routine. so it will pick a value for ‘direc’ and then it will stay the same for the whole duration of the routine
However, the polygon remains fixed at this initial position for the entire duration of the routine.
Since the position is constant, the polygon does not update its position over time.
Therefore, it stays stuck at its initial position regardless of any changes in time (‘t’) during the routine.”
What does this piece of code do? - (6)
When builder creates a psychopy experiment it makes a data structure called ‘thisExp’
‘thisExp’ is a data structure created by PsychoPy that contains all the information about the experiment.
It keeps updating this as it goes along - and at the end it saves it to disk.
If you add in your own variables to the same structure it will save them out as well
We added the variable ‘direc’
It says save my new variable called ‘direc’ (in black) into data structure called ‘thisExp’ and call it ‘direc’ (in grey) - adds it into a column in CSV file
We can place two dots on either side of trial and ‘press’ okay - (2)
And we have produced a loop and asked psychopy to runt his trial many times
In dialog box, we can change the number of trials to ‘15’
Since we saved thisExp.addData(‘direc’, direc) we can see in CSV - (2)
date = date and moment experiment started down to millisecond, tells participant session and trials - has all info for data analysis
measures framerate - how fast screen is running (e.g., 60 Hz - updates 60 times per second) like depends temp of room, graphics card - records before each trial begins
The polygon does move randomly from trial to trial (15 trials) but its haerd to know when some trials start and end - (2)
so we add ‘pre’ and ‘post’ trial within the loop by adding a routine
In each new routine add some text: ‘get ready’ and ‘respond’ for 1.0s
Close to have our experiment complete but one thing is to make measurements in this case for our polygon moving left, right or centre randomly we - (6)
collecting a keypress .
We are going to ask subjects to use the arrow keys to tell us whether the stimulus moved left, right or stayed still. ‘Left arrow’, ‘Right arrow’ and ‘up arrow’.
To do this, add another component to the ‘post’ period: a keypress after trial in post routine- allowing participants to respond after stimuli stopped moving for 1.0s
Having allowined keys in this component to be ‘left’ arrow for when polygon moving left, ‘right’ so ‘right arrow’ for when polygoin moving right and ‘up’ arrow for polygon in centre
‘Force end of routine’ ensures that the routine ends immediately after the participant responds to the post-trial instruction -
then trial loop will proceed to the next iteration until the specified number of iterations (e.g., 15) is reached. After completing the specified number of iterations, the trial loop will end,
What does this show for grating stimuli properities?
Texture within the grating stimulus has a 1-D sine wave
What does the foreground colour show for grating stimulus?
Grating stimuli will be black and white
How to produce a circular grating stimulus?
Going to change the mask to circle
How to produce 4 stripes in circular grating stimulus? - (4)
setting the Spatial Frequency parameter to 4 will indeed produce 4 stripes (4 vertical black lines and 4 white lines) within the grating stimulus.
In PsychoPy, the Spatial Frequency parameter determines the density of the stripes within the grating.
When you set it to 4, it means that within each unit of space (e.g., pixels), there will be 4 stripes.
This results in a higher frequency of stripes, making the grating appear more densely striped or patterned.
(circle now)
Placing our keyboard response withtin the trial to measure RT - (3)
using only space keypress response
Also selected ‘force end of routine’
Enabling ‘force end of routine’ means that the routine will end immediately after the participant presses the ‘space’ key - only one trial is done
“What happens in a trial routine that includes a ‘Get Ready’ text component displayed for 1.0 second, followed by a grating stimulus shown for 1.0 second, and a keyboard response allowing only ‘space’ with ‘force end of routine’ selected - , all looped for 15 trials? - (4)
“In each trial:
The ‘Get Ready’ text component appears for 1.0 second to prepare the participant.
Next, the grating stimulus is presented for 1.0 second, engaging visual perception.
Participants must respond using the ‘space’ key, triggering the ‘force end of routine’ to end the trial immediately upon response.
This entire trial sequence is repeated for a total of 15 trials, ensuring consistency and allowing for data collection across multiple iterations.” - The loop is important because we have to get lots of measurements to make a statistically-reliable estimate of the average RT.
Whats wrong with the experiment setup to measure reaction time and solution?: - (2)
“What happens in a trial routine that includes a ‘Get Ready’ text component displayed for 1.0 second, followed by a grating stimulus shown for 1.0 second, and a keyboard response allowing only ‘space’ with ‘force end of routine’ selected - , all looped for 15 trials? - (3)
In CSV under key_respon, RT is normal towards start around 200 ms but towards the end, the RT get very short around only 9 ms
What happens is individual is learning to antipcate the stimulus (anticipatory effect), the get ready! cue is taking exavtly 1 s and knowing its coming and get their finger ready and cheat on RT task
Thus, we need to get this get ready period randomised
The random wait is critical, otherwise you will just get into the habit of anticipating the stimulus and your RT will not really be a ‘reaction’.
How to randomise the ‘get ready’ cue? - (7)
Adding code element in getReady routine in which:
Set duration of ‘Get Ready’ to randTime variable
randTime equals random()*21 which generates a random floating-point number between 0 (inclusive) and 21 (exclusive) and assigns it to the variable “randTime”.
random()” generates a random floating-point number between 0 (inclusive) and 1 (exclusive).
Multiplying by 21 scales this random number to the range between 0 and 21.
. By generating a random value for “randTime”, you’re introducing variability in the timing between the grating stimulus and the onset of the “Get Ready” text.
This variability creates a variable Inter-Stimulus Interval (ISI) between the two stimuli, which can help prevent participants from predicting the onset of the “Get Ready” text
Q1
In psychopy I have created a polygon. I would like its vertical position to change with time. I have set these parameters:
What’swrong?
The position is not being updated every frame. Change the dropdown on the right to ‘Every frame’
Q2
I would like to loop my trial 5 times. What is wrong with the experiment shown here?
The loop is only placed around the ‘Get ready’ routine, not the trial itself. The dots should be on the left of ‘Get ready’ and the right of ‘Trial’
Q3
This code defines a delay before the stimulus is shown. What are the minimum and maximum possible delay values?
The rand() function returns a number between 0 and 1. So the min=2, and max=6.
Q4
I need to save the value of randTime because I suspect that the delay might influence the reaction time. When I come to look at my experiment data file it has not been saved. Here is the code. What is wrong?
There needs to be something to add randTime to the experimental data structure on each trial. Possibly this statement is in the code that is run at the end of the experiment (you can’t see that but the asterix shows that something is there), but that is too late!
Q5
I have added a new variable to the code: targetSide. What values can it take? - (4)
A5:
This question was (accidentally) a ‘trick’ one. Randint is present both in random (the standard python module) and np.random (part of numpy).
Psychopy will use the numpy version: np.random.randint(x) returns a number between 0 and x-1. So the Values this variable can take are -1 and 1.
But random.randint requires two numbers random.randint(a,b) and returns a value between a and b inclusive!
We will make sure this ambiguity is not in the actual exam.
First step of analysing data from Google sheet (importing modules) - (8)
- Importing plotting library ‘matplotlib’
- Importing from authentication modules from ‘google.colab’
- Importing authorisation libaries for sheets and colab : ‘from google.auth import default’
- Importing ‘pandas’
- ‘Importing numpy as np’
- Importing ‘scipy as ‘scipy’ which is importing scientific python
- Importing from psypy a function called ‘lingress’ which does linear regression
- Importing gspread which is a toolbox for working/ accessing with google sheets. Allowa Google Colab to reference by columns, rows , by their names so can ask for first 3 rows etc…
Second step of analysing data from Google sheet (importing modules) - (4)(authorisation)
auth.authenticate_user()
This is where we authenticate to google - asking if you are ‘Gita’
If you authenticate once you do not do it again
Login in to your account (UoY)
In here, we are giving one website (Colab) the permission to access another web document (shared google spreadsheet) using your Google account information
Second step of analysing data from Google sheet (importing modules) - (2)(authorisation)
gc = gspread.authorize(cred)
This gets you a ‘google cloud’ handle/an authentication token
If you show this token ten Google will believe its ‘you’
Third step of analysing data from Google sheet (looking at the data) - (6)
Use the handle you just acquired to open the spreadsheet. Going to ask Google to open up spreadsheet of psychopy by giving them the handle to the workbook using web address of spreadsheet
- ‘wb=gc.open_by_url(‘https://docs.goog…’ : Here we get a handle to the workbook (wb) using the web address of the spreadsheet. That gc module is ‘google cloud’.
- data.wb.sheet1.get_all_values() - gets all the values from spreadsheet
-dArray = np.array(data) - turns all values of spreadsheet into numpy array which is mix of strings and numbers
- print(dArray[0,[1,2,3,4]]) - using indices [1,2,3,4] of the first row in ‘dArray’ - Access the first row of the numpy array ‘dArray’ using index 0 - print the header strings
- print(dArray[1:21,[1,2,3,4]])Print data (numbers) from rows 1 to 20 and columns 1 to 4 of ‘dArray’.
- fArray=dArray[1:21,[1,2,3,4]].astype(float) - Convert the sliced portion of ‘dArray’ containing numerical data into a numpy array of floats (fArray).
Code plotting the linear regression of dominant and non-dominant hand - explanation
RTs=(fArray[0:,[0,1]]) - # Extract RTs and other important variables. The variable ‘RTs’ will contain the data from columns 0 and 1 of ‘fArray’, which represent the RTs for the dominant and non-dominant hands respectively.
handedness=fArray[0:,2] - This line extracts the data from the third column of ‘fArray’, which represents handedness.
height=fArray[0:,3] This line extracts the data from the fourth column of ‘fArray’, which represents height.
for thisRTHand in range(2): - This line initializes a loop that iterates twice, once for each hand (dominant and non-dominant).
plt.subplot(1,2,thisRTHand+1) # Two subplots
plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=1, hspace=0) # Make the spacing nice
- These lines set up the subplot configuration, creating two subplots side by side.
They adjust the spacing between subplots for better visualization.
plt.scatter(height,RTs[:,thisRTHand]) - This line creates a scatter plot with height on the x-axis and RTs for the current hand (dominant or non-dominant) on the y-axis.
(m, c, rvalue, pvalue, stderr) = linregress(height,RTs[:,thisRTHand]) # height on x axis and RT on y axis - This line performs linear regression analysis to calculate the slope (m), intercept (c), correlation coefficient (rvalue), p-value (pvalue), and standard error (stderr) of the regression line -height on x axis and RT on y axis, m gradient, c offset, r value and p-value
y_pred = c + m*height # Make predictive y values based on height
plt.plot(height,y_pred, color=”red”, label=”Fit”)
These lines generate the predicted values (y_pred) using the equation of the regression line.
They plot the regression line on the scatter plot, indicating the relationship between height and RTs as a red line
plt.text(175,325,f”p={pvalue:.2f}”) # Places p-value of each scatter plot and r value
plt.text(175,340,f”r={rvalue:.2f}”) -These lines add text to the plot, displaying the p-value and correlation coefficient (r-value) with appropriate formatting - showing how much variation is explained in r value
plt.ylim(150,400) # Scale all plots to the same axes
plt.xlabel(“Height (cm)”)
plt.ylabel(“RT (s)”)
These lines set the y-axis limits for consistency across all plots and label the axes appropriately.
plt.show() - This line displays the plot to the user interface.
Output of this code:
What does this code show? - (2)
There doesn’t seem to be a general effect of height on either LH or RH reaction times. We could pool all the RTs in some way to get a more robust estimate but it is still almost certainly n.s.
One thing we might expect is that the dominant hand is faster than the non-dominant hand. To check this we can use a a t-test test.
Before you conduct at-test you should plot the data - (3)
Plotting data from categories is often best done with a boxplot.
This gives you a nice way of comparing the data ‘side by side’ and also computes and plots measures of spread automatically.
The ‘notch’ in the boxplot is very useful: It is a measure of the confidence interval. If notches from two groups don’t overlap it’s a good indication that they have different central tendencies.
Explain this code of producing boxplot before conducting t-test:
Boxplots of for the reaction times (RTs) of dominant and non-dominant hands - (7)
‘notch=True’ adds a notch indicating the confidence interval around the median - gives estimation of CI around the centre (median)
Label the x-axis ticks as ‘Dominant’ and ‘NonDom’ corresponding to the two boxplots.
plt.show() - display graph
Perform a paired-sample t-test using scipy.stats.ttest_rel() - asks to psypy for relative value t-test
- The t-test compares the means of two paired groups to determine if there is a significant difference.
- ‘RTs[:,0]’ and ‘RTs[:,1]’ represent the RTs for dominant and non-dominant hands respectively - of first and second column
Print the results of the paired t-test including the t-value and p-value with 3 significant figures - print(f’Paired t-test t={t:.3} | p={p:.3}’)
What does the output show? - (3)
- Shows the dots and extreme values, someone people have extreme RTs - very slow or very fast
- Orange lines is median values, these are similar in dominant and non-dominant hand
- V shape is the notices and rule of thumb is notches overlap probably no sig difference - so we don’t have sig diff - no relationship of RT and height, no relationship between RT and dominantness of hand
Here we will use an external data file (in .csv or .xls format) to control the
conditions.
To make 2 conditions in psychopy experiment make csv file containing
We save this csv file as the
n the same directory as your experiment. We will soon import this file into psychopy.
In psychopy, in this csv file - (2)
Psychopy interprets the column headers as variable names.
And for each ‘iteration’ of the loop it can assign the values from one row to those variables - each containing a number and string from two column
Now in our RT experiment from last week (W5) we can add the csv file of two conditions
This tells… - (3)
We want psychopy as it loops around the trial, in each iteration of loop we would like to pick a random finger and show us something on screen which finger to use
The way in which psychopy we have a data file available that lists conditions is in conditions tab - we tell where conditions list file CSV and tells you found 5 conditions (how many rows you got), 2 parameters and variables names are called finger, string
Each time Psychopy goes around the loop, it will pick values from one row of each of the 2 variables at random - since set loopType to random
We now need to tell the subject which finger to use on each trial. To do this, we will print a little bit of text on the screen just before the trial saying something like Pinky or Thumb.
We will do this by changing the text that originally said ‘Ready’ - (3)
Open up the ‘GetReady’ component. There are two items in the timeline: some code (which is used to randomize the ISI) and some text. Last week that text said ‘Ready…’. We will now change it to reflect the finger that you are supposed to use.
Change the text to $String
In each iteration of loop, we want psychopy to tell what value of string is and place into textbox
How many trials should we have if nReps is 5 and we have 5 conditions?
25 trials
We can set trial type into sequential in which or staircase
sequential is not randomise
We can produce a new experiment which randomising faces of images
this is what we have in our face folder once we unzip:
To add our face images, we can add a ‘picture’ stimulus to my trial
can make a CSV file called ‘faceFile’ column and adding images into CSV file from our folder
then name of the picture will be a variable called $faceFile
note… names in column A must match the filenames of the images you just downloaded in the face file
Finally, add a loop around the image presentation. In the loop point it to your .csv file. It should say that it found 1 parameter with three values… like this:
If you have done all this correctly, when you run the experiment, it will load the face images in ‘on the fly’ according to which image is currently selected in the (random) loop.
If you have lots and lots of images then sometimes it’s annoying to have them in the same directory as your experiment. You want to ‘tuck them away neatly’ in a subfolder like this:
In that case, you just need to tell Psychopy where they are relative to the experiment. There are lots of ways to do this. One way is to add the subdirectory into the “image” location in the image properties - (2)
Notice what we have done here - we have embedded some python code directly into the entry box in the image properties tab (os.path.join(xxx,yyy)). To do this, you should preface the code with a dollar sign ($)
There are lots of other ways to make this happen: One way is to include the directory name into the file name in the .csv file. Or you could add a bit of code in the stimulus routine that builds a filename from a constant and the faceFile variable.
Calbiration
Scientists want to make sure that the stimuli they run are the same no matter where in the world they are. This way someone can replicate your experiments and check your results.
If you make a stimulus that is ‘40% of the screen’ or ‘100 pixels wide’ then it is very hard to know how big it actually appears to someone. How big was the screen? How far away was the subject? What were the brightness / contrast settings? Was it a gaming monitor or a projector or what?
As we all know, things that are far away can appear small.
To standardise our measurements, vision scientists like to measure the size of things in ‘visual angle’. This is the angle that lines from the edges of your stimulus make at your eye. As a rule of thumb (literally), your thumb is about 1.5-2 degrees of visual angle at arm’s length. They also measure other things like the brightness of the screen and how the colors look.
This process of setting up a display is called ‘calibration’. Your experiment right now is using a standard calibration that is often more or less okay. You can see the monitors available to you under the ‘monitor’ menu (Tools->Monitor Centre). Probably there is only one.
The monitor that you are actually using for your experiment is defined in the ‘Experiment settings’ panel. Under ‘screen’ you tell it the monitor name and some other things….
Notice that at the moment you are defining all your measurements in units of ‘screen height’. That’s not ideal - screens have different heights and people can sit at different distances from the screen. In the future we will change this to ‘degrees’ (deg) and define all our sizes in terms of visual angle.
It would be this if laid out like this
with faceFile as column header of csv
Would be this is laid out like this
The RP2040 is a computer. Like all computers it needs an
You are used to… - (2)
‘operating system’.
You are used to computers already coming with different operating systems (Windows, Linux, macOS)… but you will need to install one on the RP2040.
You will download an operating system for the RP2040 from a website and then
install it over the USB cable
However, today we will settle for making the onboard LED flash different colours.
The LED is the
white dot between the two buttons.
We can download neopixel via a link and - (3)
drag neopixel.mpy into ‘lib’ (where it likes to store all its libaries)
The library file you downloaded is called neopixel.mpy
Drag this over to the lib folder on the RP2040 in the file explorer
At top is the code the device is run and at the bottom is the - (4)
input and output of the computer
What your desktop is doing is talking to the other machine the other computer through a serial line (this pops up when pressing ‘Serial’ (‘S’ in USB’) and if machine prints something it outputs in serial terminal
If you enter some text, it will go back to the other computer
Can reload things by saying Control D
Explain this code that we will put in muEditor line by line - (10)
import time: This line imports the time module, which provides various time-related functions.
import board: This line imports the board module, which provides access to the pins on the microcontroller board.
import neopixel: This line imports the neopixel module, which allows control of NeoPixel LEDs.
led = neopixel.NeoPixel(board.NEOPIXEL, 1): This line creates a NeoPixel object named ‘led’ using the neopixel library. It specifies that the LED is connected to the pin labeled NEOPIXEL on the microcontroller board, and there is only one LED.
led.brightness = 0.3: This line sets the ongoing brightness of the LED to 30% of its maximum brightness.
while True:: This line starts an infinite loop that will continuously execute the code block that follows.
led[0] = (255, 0, 0): This line sets the color of the LED to red. The NeoPixel library represents colors as tuples of three integers, representing the amount of red, green, and blue respectively. Here, (255, 0, 0) represents full red, no green, and no blue.
time.sleep(0.5): This line pauses the execution of the program for 0.5 seconds, causing a half-second delay.
led[0] = (0, 0, 0): This line turns off the LED by setting its color to black. In the NeoPixel library, (0, 0, 0) represents no red, no green, and no blue, effectively turning off the LED.
time.sleep(0.5): This line again pauses the execution of the program for 0.5 seconds, creating another half-second delay before the loop repeats.
What would this code effectively do?
The board will automatically reboot (thanks to the magic of muEditor) and a red light should blink on and off.
led.brightness = 0.99 would make.. - (2)
Setting the LED brightness to 0.99 makes the LED nearly at its maximum brightness.
In the NeoPixel library, the brightness attribute ranges from 0 (off) to 1 (full brightness).
Code: Setting both to be the same - (2)
time.sleep(0.5)
time.sleep(0.5)
Setting both time.sleep() calls to the same duration, such as 0.5 seconds each, creates a square wave pattern with a 50% duty cycle.
This means the LED blinks on and off at regular intervals, with each state lasting for the same amount of time.
If I alter duty cycle by having - (2)
time.sleep(0.8)
time.sleep(0.2)
By setting time.sleep(0.8) for the on state and time.sleep(0.2) for the off state, the duty cycle of the square wave pattern is altered.
The LED will be on for a longer duration compared to being off, resulting in an increased duty cycle.
If you divide time.sleep by 10 , LED will flicker
faster
Explain what this code would do if we put in muEditor of file code.py? - (13)
import time: Imports the time module, which provides various time-related functions.
import board: Imports the board module, which provides access to the pins on the microcontroller board.
import math: Imports the math module, which provides mathematical functions. - importing another library to do maths
import neopixel: Imports the neopixel module, which allows control of NeoPixel LEDs.
led = neopixel.NeoPixel(board.NEOPIXEL, 1): Initializes a NeoPixel object named ‘led’ using the neopixel library. It specifies that the LED is connected to the pin labeled NEOPIXEL on the microcontroller board, and there is only one LED.
led.brightness = 0.3: Sets the ongoing brightness of the LED to 30% of its maximum brightness.
freq=2: Sets the frequency of the sinusoidal wave to 2 Hz.
startTime=time.monotonic(): returns the current elapsed time since the device was turned on in second using time.monotonic()
while True:: Starts an infinite loop that will continuously execute the code block that follows.
eTime=time.monotonic()-startTime: Calculates the elapsed time since the loop started using time.monotonic() in seconds
val=int(math.sin(eTime2freq3.1415)127+128): Calculates the brightness value for the LED based on a sinusoidal function. math.sin() calculates the sine of the input value (in radians), and the result is scaled to fit the range of NeoPixel brightness values (0-255). - basically calculating sine based on what the current elapsed time is (‘eTime’)
led[0] = (val,val,val): Sets the color of the LED to a grayscale value determined by ‘val’. This creates a pulsating effect from black to white based on the sine function - RBG all the same - black to white
time.sleep(.05): Pauses the execution of the program for 0.05 seconds, creating a delay between each iteration of the loop. This controls the speed of the pulsating effect.
What would happen to the LED?
The LED brightness would pulsate in a sinusoidal pattern, transitioning from black to white and back again, at a frequency of 2 Hz.
How to make the LED pulsate a bit slower? - (2)
To make the LED pulsate slower, adjust the frequency of the sinusoidal wave.
By changing the value of freq to a lower number, such as 0.5 Hz, the LED will pulsate at a slower rate, resulting in a the LED will pulsate at a slower rate, resulting in a slower transition between brightness levels, with one cycle occurring every 2 seconds or freq to 0.25 within a very slow transition between brightness levels, with one cycle occurring every 4 seconds.
To make LED pulsate faster then change freq variable to values like - (2)
To make the LED pulsate faster, increase the frequency of the sinusoidal wave. By changing the value of freq to a higher number, such as 2 Hz, the LED will pulsate at a faster rate, resulting in a quicker transition between brightness levels, with two cycles occurring every second.
OR To make the LED pulsate even faster, further increase the frequency of the sinusoidal wave. By changing the value of freq to a higher number, such as 5 Hz, the LED will pulsate at a rapid rate, resulting in a very quick transition between brightness levels, with five cycles occurring every second.
If you change led[0] to not be all val but instead be
led[0] = (val, 0, val) then… - (2)
By modifying the LED color to (val, 0, val), you’re creating shades of purple, as it mixes red and blue while keeping green constant at 0.
This changes the LED’s color from grayscale to various shades of purple, transitioning in a sinusoidal pattern as the brightness value (val) changes over time.
If you change led[0] to different stuff like:
led[0] = (val, 0, 0) - (3)
By setting led[0] = (val, 0, 0) - Adjusts LED brightness, creating red pulsating from off to bright red.
led[0] = (0, val, 0) - Adjusts LED brightness, creating green pulsating from off to bright green.
led[0] = (0, 0, val) - Adjusts LED brightness, creating blue pulsating from off to bright blue.
In this code, we set to muEditor, we doing something super fancy, such as setting each R,G,B component at slightly different frequency and as they drift apart and together in phase, you should see the LED make all the different possible colours like a rainbow and pulsate at different colours
Explain this code line by line - (9)
Imports necessary modules: import time, import board, import neopixel, and import math.
-
Defines frequencies and constants:
f1=1.1,f2=1.2,f3=1.3, andpi=3.1415. -
Initializes NeoPixel object:
led = neopixel.NeoPixel(board.NEOPIXEL, 1). -
Sets LED brightness:
led.brightness = 0.3. -
Records the start time:
startTime=time.monotonic(). -
Starts an infinite loop:
while True:. -
Calculates elapsed time:
thisTime=time.monotonic()-startTime. -
Computes brightness values for RGB components:
a1=(math.sin(thisTime*2*pi*f1)*127+128)a2=(math.sin(thisTime*2*pi*f2)*127+128)-
a3=(math.sin(thisTime*2*pi*f3)*127+128).
-
Sets LED color:
led[0] = (a1,a2,a3).
What happens setting all the different frequencies close together? f1,f2,f3? - (2)
f1=1.17
f2=1.2
f3=1.22
By making the frequencies closer together, such as setting f1=0.5, f2=0.6, and f3=0.7, the LED’s color modulation (colour shift) occurs at a slower rate.
This adjustment results in a smoother color transition with less noticeable changes, as the frequencies drift apart and together at a slower pace.
If you open the plotting panel:
It plots the data( numbers) it receives from the computer board
muEditor has a built-in plotter that will plot numbers it receives on the serial line if you send them as tuples (enclosed in round brackets like this: (10,20,30). For example, try this code and switch to the plotter mode:
Explain this code line by line - (7)
Imports necessary modules: import time and import random are used to import modules providing time-related functions and random number generation, respectively.
-
Starts an infinite loop:
while True:initiates a loop that will run indefinitely. -
Introduces a pause:
time.sleep(0.05)introduces a 0.05-second pause between iterations of the loop. This pause prevents flooding the serial line with data. -
Generates random temperature data:
random.randint()is used to generate random integers representing temperature readings.- The first temperature (
random.randint(0, 100)) is generated within the range 0 to 100, representing temperatures between 0°C and 100°C. - The second temperature (
random.randint(-100, 0)) is generated within the range -100 to 0, representing temperatures between -100°C and 0°C. - The third temperature (
random.randint(-50, 50)) is generated within the range -50 to 50, representing temperatures between -50°C and 50°C.
- The first temperature (
-
Prints temperature data:
print()function is used to print the generated temperature data as tuples(temperature1, temperature2, temperature3)to the serial line.
What is the output of this code? - (4)
The code is paused in while loop for 0.05 s
This code will produce three random numbers (stored in tuples) and plots them
Then goes stop of code and repeats that
These tuples of random numbers can be plotted using a serial plotter tool in the development environment.”
It prints the output because The way in which it gets the numbers out of the device is making them as a tuple , the brackets and separate them by comma
meaning…
- (3)
“The ‘device’ refers to the RP2040 microcontroller.
It generates the random numbers as tuples, encapsulating them within parentheses and separating them by commas.
This formatting ensures that the numbers are structured as a tuple before being transmitted through the serial line to the computer.”
The RP2040 has a built-in thermometer that will read the temperature. You can read this thermometer like this: - (2)
“This code snippet utilizes the microcontroller module to access the built-in thermometer of the RP2040 microcontroller.
Specifically, it reads the temperature using the cpu.temperature attribute, which retrieves the temperature of the RP2040 microcontroller itself, and assigns the temperature value to the variable temp.”
Explain this code - (7) (remove dot at the end)
-
Accessing Microcontroller Temperature: The code utilizes the
microcontrollermodule to access the built-in thermometer of the RP2040 microcontroller. Specifically, it reads the temperature usingmicrocontroller.cpu.temperature. -
Storing Temperature in Variable: The temperature value is read and stored in the variable
temp. -
Sending Temperature as Tuple: The temperature value stored in
tempis sent out as a tuple along with reference values of 0 and 37.5°C. This tuple is printed to the output. -
Looping Continuously: The code runs in an infinite loop (
while True:) to continuously read and send temperature data. -
Introducing Pause:
time.sleep(0.1)introduces a short pause of 0.1 seconds between each iteration of the loop to prevent overwhelming the serial line. -
Temperature Variation: By placing the device in hand, the temperature sensed by the microcontroller may vary, leading to changes in the temperature readings stored in
temp. - Visualizing Data in muEditor: The additional reference points of 0 and 37.5 help muEditor to autoscale the plotter for better visualization of the temperature data.
Explain this code - (6)
These lines import necessary modules: time for time-related functions, microcontroller for accessing microcontroller-specific functionalities, neopixel for controlling NeoPixel LEDs, and board for accessing pin mappings. - importing at top
This function create_colormap(n) generates a colormap with n steps, transitioning from blue to green to red. It loops over a range of n values and calculates RGB values based on the current step. The colors transition from blue to green for the first half of steps and from green to red for the second half. - def function
This line initializes a NeoPixel object led to control the onboard LED connected to the pin NEOPIXEL. - led = neopixel.NeoPixel(board.NEOPIXEL, 1)
These lines define parameters: nSteps specifies the number of steps in the colormap, while minTemp and maxTemp set the temperature range to measure over. - nSteps = 20
minTemp = 32.0, maxTemp = 42.0
This line calls the create_colormap() function to generate the colormap based on the specified number of steps - cMap = create_colormap(nSteps)
while true loop - This block of code runs in an infinite loop (while True:) to continuously monitor the temperature.
time.sleep(1) introduces a 1-second delay between temperature readings to avoid flooding the CPU.
temp = microcontroller.cpu.temperature reads the temperature from the microcontroller.
index calculates the index within the colormap based on the temperature reading.
Conditional statements ensure that the calculated index stays within the valid range.
led[0] = cMap[int(index)] sets the color of the onboard LED based on the colormap and the calculated index.
print((0, temp, 37)) prints the current temperature, along with reference values of 0°C and 37°C, as a tuple.
What does this code achieve? - (3)
We can make the RP2040 into a very primitive ‘standalone’ thermometer.
Write code based on the two examples above to set the LED colour based on the temperature. The tricky bit here is working out the colours. We want to set the colours over a range from about 30 to 42c with 30 being ‘blue, 37 (ish) being ‘green’ and 42 being red.
Probably the easiest way to do this is to make three lists of numbers for the R, G anb B LEDs. They will go from (255 ->0->0) for B, (0->255->0) for G and (0->0->255) for R with 200 numbers or so in each range. Then we will pick the R,G,B values based on the current temperature.
Explain the def function - (6)
-
Function Definition: The
create_colormap()function is defined to generate a colormap with a specified number of steps (n). -
Colormap Initialization: An empty list
colormapis initialized to store the RGB values of each step in the colormap. -
Looping Over Range: The function iterates over a range of values from 0 to
n-1using aforloop. -
Color Calculation: Depending on the value of
i, the function calculates the RGB values for each step of the colormap.- For values of
iless thann // 2, it calculates the green component (g) based on the ratio ofito half ofn, and the blue component (b) as the complement to 255. - For values of
igreater than or equal ton // 2, it calculates the red component (r) based on the ratio of the difference betweeniand half ofnto half ofn, and the green component (g) as the complement to 255. The blue component (b) is set to 0.
- For values of
-
Appending to Colormap: The calculated RGB values are appended to the
colormaplist as tuples(r, g, b). - Returning Colormap: Finally, the function returns the generated colormap.
What does this code do? - (6)
- This code is used to download a smaller version of a repository called ‘pin-material’ from a specific URL.
- The ‘!cd /content’ command changes the directory to ‘/content’.
- ‘!git clone –branch small –depth 1 https://vcs.ynic.york.ac.uk/cn/pin-material.git’ is the main command.
- It clones the ‘small’ branch of the repository with a depth of 1, meaning it only gets the latest version of the files, not the entire history.
- The comment explains that this smaller version doesn’t include neuroimaging data, making it much smaller than the full repository.
- The ‘!ls -lat’ command lists the contents of the current directory in detail, showing the latest changes first.
Explain this code (using YNiC’s git server to download useful files like pin-material-git) - (8)
- This code uses the
osmodule -
os.getcwd()prints the current working directory. -
os.listdir('.')lists the contents of the current directory.and stores in variable called ‘contents’ -
'.'represents the current directory. -
type(contents)prints the type of the variablecontents. -
print(contents)prints the contents of the current directory. -
os.listdir('/content/pin-material')lists the contents of the ‘/content/pin-material’ directory - different directory and stores into variable ‘newcontents’ - contents of ‘newcontents’ variable is printed out
Output of this code
This is what pin-material directory looks like in file format:
Example of os.listdir() including hidden files (e.g., .DS_Store)
Example of using glob on YNiC pin material
Example of using YNiC pin material directory
Explain the code - (5)
- Importing the glob function is achieved with
from glob import glob. -
filelist = glob('/content/pin-material/*.jpg')finds all .jpg files in the ‘pin-material’ directory. -
print(filelist)displays the list of .jpg files found. -
pyFiles= glob('/content/pin-material/*.py')finds all Python script files. -
print(sorted(pyFiles))prints the Python script files as a sorted list - in ascending order
Output of this code:
Can use sorted function to find these hidden files first when using os.listdir
How to import three os functions that help you with spilting full file paths using os module?
basename, dirname, split text?
Explain this code - (8)
The code first imports necessary modules from glob module and basename, split text and dirname functions from os module
Use glob to find files:
The glob function searches for all files ending with ‘.hdf5’ in the ‘/content/pin-material/s4/’ directory.
The resulting list of file paths is stored in the fileList variable.
A for loop iterates over each file path in fileList.
In each iteration of element in fileList,
fNameOnly stores the filename extracted from the full path thisFileName (e.g., if thisFileName is ‘/content/pin-material/s4/s4_rt_data_part04.hdf5’, then fNameOnly will store ‘s4_rt_data_part04.hdf5’.
parts variable = splitext (fNameOnly) so splitext splits the filename stored in fNameOnly into its base name and extension. The base name is stored in parts[0].
For example, if fNameOnly is ‘s4_rt_data_part04.hdf5’, then after splitting:
parts[0] will store ‘s4_rt_data_part04’ (the base name).
print(parts[0]):Only the base name stored in parts[0] is printed. For example, if parts[0] is ‘s4_rt_data_part04’, then this base name will be printed.
For loop continues until each element of list in fileList is covered
Output of this code
For cases where we need to implement a simple transformation like this (such as multiplying by a number or calling a function on each member of a list), like in this example,
Python gives us an alternative: the list comprehension.
How to write this list ‘outputlist’ into list comprehension?
Explain this code - (2)
The example above therefore reads as (x * 2) for each value (x) in range(10). i.e., for each value in the list produced by range(10), put it in the variable x, then put the value x*2 into the list.
Note that the variable x is just a placeholder and could be called anything.
What would be output of this code?
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Explain this code - (6)
-
original_data = ['Alex', 'Bob', 'Catherine', 'Dina']: Defines a list namedoriginal_datacontaining four strings. -
new_list = ['Hello ' + x for x in original_data]: Utilizes list comprehension to create a new list namednew_list.- For each element
xinoriginal_data, the expression'Hello ' + xconcatenates ‘Hello ‘ with the value ofx, which represents each name in original_data. - The resulting strings are added to
new_list.
- For each element
-
print(original_data): Prints the contents oforiginal_data, displaying the original list of names. -
print(new_list): Prints the contents ofnew_list, displaying each name prefixed with ‘Hello ‘.
What would be output of this code?
Explain this code - (6)
-
original_data = ['This', 'is', 'a', 'test']: Defines a list namedoriginal_datacontaining four strings. -
new_list = [len(x) for x in original_data]: Utilizes list comprehension to create a new list namednew_list.- For each element
xinoriginal_data, the expressionlen(x)calculates the length of the stringx. - The resulting lengths are added to
new_list.
- For each element
-
print(new_list): Prints the contents ofnew_list, displaying the length of each string inoriginal_data. - For example, ‘This’ has 4 characters, ‘is’ has 2 characters, ‘a’ has 1 character, and ‘test’ has 4 characters.
What would be output of this code?
What would be output of this code?
What would be output of this code?
Example of using pass in an empty loop - (5)
-
data1 = [10, 20, 30]creates a list of numbers from 10 to 30.- The for loop iterates over each item in
data1. - Inside the loop, a comment explains that the loop is pointless but serves as a placeholder for future code.
- The pass statement is used to indicate that no action needs to be taken inside the loop.
- The for loop iterates over each item in
- Essentially, pass allows the loop to exist without any executable code inside it, avoiding syntax errors in situations where a loop is required but no action is necessary.
What would be output of this code? - (3)
The pass statement itself does nothing when executed and serves as a placeholder.
- As a result, there are no print statements or other operations that would produce output
NO OUTPUT
Explain the use of break in this code snippet - (5)
- It imports the randint function from the random module to generate random integer numbers.
- Inside a while loop that runs indefinitely (while True), random numbers between 0 and 5 (inclusive) are generated and printed.
- If a randomly generated number is equal to 0 printed, the break statement is executed.
- The break statement immediately terminates the while loop, exiting the loop and ending the program execution.
- This allows the program to stop generating random numbers once a 0 is encountered.
Plain text files can be formatted in a number of ways, but a common way for numerical data is:
i.e., numbers separated - either by spaces, tabs or commas with one row per line of text.
We are going to load some MEG data from the file s4_meg_sensor_data.txt in the
pin-materials s4 sub-directory using this code:
Explain what this code does - (6)
!ls -lh pin-material/s4
The ls command lists the contents of a directory.
-
-lhis a combination of options:-
-llists detailed information about each file, including permissions, owner, size, and modification time. -
-hdisplays file sizes in a human-readable format (e.g., kilobytes, megabytes).
-
-
pin-material/s4specifies the directory whose contents will be listed. - Therefore, this command lists detailed information about the contents of the “s4” subdirectory within the “pin-material” directory.
Explain what this code does - (3)
!head pin-material/s4/s4_meg_sensor_data.txt
The head command displays the beginning of a file.
-
pin-material/s4/s4_meg_sensor_data.txtspecifies the file whose beginning will be displayed. - This command shows the first few lines of the “s4_meg_sensor_data.txt” file located within the “s4” subdirectory of the “pin-material” directory.
By executing this code:
It gives us this output
This output shows - (8)
We can see that the first line of the file contains some column headings.
We make a note of these as we will need them later on:
Column 0: Time
Column 1: Left Mean
Column 2: Left Lower CI
Column 3: Left Upper CI
Column 4: Right Mean
Column 5: Right Lower CI
Column 6: Right Upper CI
Executing this code line gives us this output:
We can use the tail command on MEG data to check 10 lines of the file are really numbers
What does the following code snippet do, and why might it encounter an issue?
The code snippet uses NumPy’s “loadtxt” function to load numerical data from a text file.
- It attempts to load data from the file “s4_meg_sensor_data.txt” located within the “s4” subdirectory of the “pin-material” directory.
- However, it may encounter an issue if the first line of the file contains column names or non-numeric data instead of numerical values.
- By default, “loadtxt” expects numeric data and will raise an ValueError error if it encounters non-numeric content in the first row.
We can correct this by:
telling nump to skip the first line (skip first row) which contains t is the header with column names which is string - words
What would be the shape of the data and type?
(400, 7) - 400 rows and 7 columns
float64
Explain the code - (9)
This code snippet uses NumPy’s “loadtxt” function to load numerical data from a text file.
- It loads data from the file “s4_meg_sensor_data.txt” located within the “s4” subdirectory of the “pin-material” directory, skipping the first row (which likely contains column names or non-numeric information).
- The loaded data is stored in the variable “importedData”.
- This line extracts a subset of the loaded data (“importedData”).
- It selects columns 1, 2, and 3 (exclusive indexing) from the loaded data.
- The extracted data, representing the timecourse and confidence intervals, is stored in the variable “ourdata”.
- The “savetxt” function from NumPy is used to save the extracted data (“ourdata”) to a new text file named “my_new_meg_data.txt”.
- This file is saved in the “/content/pin-material” directory.
- After saving the data, the “!ls -lth” command is executed to list the files in the directory, providing information about file sizes and modification times.
explain what this line np.savetxt mean in this code - (6)
np.savetxt: This function from the NumPy library is used to save data to a text file.
‘my_new_meg_data.txt’: Specifies the name of the text file where the data will be saved.
ourdata: Represents the data to be saved. This variable holds the extracted subset of the loaded data, which includes columns 1, 2, and 3.
header=’Mean UppcrCI LowerCI’: Defines a header string that will be written at the beginning of the file.
This header typically contains column names or other descriptive information. In this case, the header string specifies the column names as “Mean”, “UppcrCI”, and “LowerCI”.
fmt=’%1.4e’: Specifies the format string for writing the data. The %1.4e format specifier formats floating-point numbers with scientific notation (exponential format) and exactly 4 digits after the decimal point. This ensures that the data is written with a precision of 4 decimal places.
Plot data as a list - example code
Explain whats happening in plt.plot([0,1,2,3]) - (4)
Since only one set of values is passed, these values will be used as the y-values, and the x-values will be automatically generated as the indices of the data points (0, 1, 2, 3).
In this example, we did not supply an ‘X’ axis. matplotlib assumed that we just wanted 0,1,2,3 and so on.
So we really plotted (0, 2), (1, 3), (2, 4) and (3, 5) and joined them up with a straight line.
When matplotlib draws a line in this way, it joins the points with straight lines by default.
We might, however, want to look at the individual data points. To do this, we can add a ‘format’ string - (2)
This is a string which describes how to format the data in the plot.
Here we do this by just adding an ‘o’ to the function call.
What does this line of code do?
plt.plot([2, 3, 4, 5], ‘o’)
The first line plots the data points as circles (‘o’) without joining lines, creating a scatter plot.
What does this line of code do?
plt.plot([2, 3, 4, 5], ‘og’)
The second line plots the same data points as green circles (‘og’) without joining lines.
What does this line of code do?
plt.plot([2, 3, 4, 5], ‘o–’)
The third line plots the data points as circles with a dashed line (‘o–’) joining them.
We can combine markers and colours in same format string:
Explain what this code does and output - (5)
-
import matplotlib.pyplot as plt: Imports the Matplotlib library and aliases it aspltfor convenience. -
plt.cla(): Clears the current axes to ensure a fresh plot. -
plt.plot([2, 3, 4, 5], 'r+'): Plots the data points [2, 3, 4, 5] with red plus markers (‘r+’).
The ‘r’ indicates the color red, and the ‘+’ specifies the marker style as a plus sign.
The datapoints are not joined by a line
What does this code line do?
This code plots the points [2, 3, 4, 5] using blue stars at each data point with a dash-dotted line in between.
We can pass two lists/arrays of numbers first will be x value and second y values like this:
What does this code do: plt.plot([-2, 1.5, 2, 4], [2, 3, 4, 5], ‘g*’)?
This code plots a graph with green star markers at the coordinates (-2, 2), (1.5, 3), (2, 4), and (4, 5),
E.g.,
The default behaviour of matplotlib is to add plots of new data to the existing figure. This allows us to create complex plots from multiple components.
A simple example would be a line plot with many lines of data, or a scatter plot where we show different types of data with different symbols
What does plt.ylim do?
set limits of y axis go from -3 to +4
What does plt.grid() do?
even put a beautiful grid on it
What does plt.savefig(‘my_figure.png’, dpi=300)
This code saves the current figure as an image file named “my_figure.png” with a resolution of 300 dots per inch (dpi).
Using can either select the figure and then use plt.savefig()
can use the .savefig() method directly on the figure object.
figureHandle = plt.figure()#Generate a new figure. Hold its ‘ID’ or ‘Handle’ in a variable
what does legend part do in this code: import matplotlib.pyplot as plt? - (2)
The plt.legend() function adds a legend to the plot, which provides labels for the plotted lines.
In this code, it labels the first line as “A straight line” and the second line as “A wiggly line”.
We can add new line character inside x-axis label and y-axis level via:
Why is one line blue and one line green in this code and plot? - (3)
In the provided code, the line plt.plot([2, 3, 4, 5]) creates a plot with only y-values, so it auto-generates x-values as sequential integers starting from 0.
This line is plotted in the default color, which is blue.
The subsequent line plt.plot([-2, 1.5, 2, 4], [2, 3, 4, 5], ‘g’) plots the provided x and y values in green color as specified by the ‘g’ argument.
What does plt.text do in this code? - (2)
The plt.text() function in this code adds text to the plot at a specified location.
In this case, it adds the text “Hello World” at the position (2, 2) on the plot, with the color set to red.
Explain this code plotting MEG data - (6)
np.loadtxt() loads data from a text file, skipping the first row.
Time data is stored in the first column (t).
Sensor readings from columns 1 and 4 are extracted (plot_dat).
plot_dat.shape prints the size of the extracted data - (400, 2) rows column
plt.plot(t, plot_dat) plots sensor data over time.
Legends and gridlines are added for clarity.
Wait in this code
There are two lines but only one plt.plot call! What has happened? - (3)
Until this point, each of our plt.plot() calls has only plotted a single line. If there are multiple columns in the data passed to plot_dat, matplotlib will automatically plot multiple lines - magic!
We have passed values for the x axis in (t: the time variable),
Notice that we have time before 0s. Time 0 is the time we present the stimulus (in this case a ‘beep’). We see that we get a large deviation in the signals shortly after the presentation of the stimulus.
The MEG signals we have plotted so far are the
are mean response across multiple presentations of the same ‘beep’
What does plt.fill_between show? - (4)
Plots the error enevelope - shaded area between let_lower_ci and left_upper ci on the plot along time axis
t parameter is added to define x-axis values
left_lower_ci = data[:, 2] - extracts data from column 2 lower CI
left_upper_ci = data[:, 3] - extracts data from column 3 of upper CI
We would also like to plot the mean line (as well as error envelop) by
first plotting the mean line in black using plot.plot() (color=’k’), then plotting the error envelope over the top (plt.fill_between()).
When we plot over the top we have to set the color to be a bit transparent otherwise you will not see the line below.
Computers often refer to the transparency or ‘solidness’ of a color as its ‘alpha’ value. So if we set ‘alpha’ to 0.5, it will become 50% see-through. 20% is even more see-through.
We can specficy colours to plt.plot in different ways such as - (3)
specificy single letter ‘r’ = ‘red’
Red , green, blue format
Using colour names like aquamarine, mediumseagreen
Wha does plt.figure() and plt.hist(data1, bins = 50) show?
plt.figure() - produce a figure for the histogram
plt.hist(data1, bins = 50)
x axis = range of values in dataset data1 divided by 50 bins
Y axis is frequency or count of occurence of data points falling within each bin on x axis
specifices bins - how lumpy i want histogram to be
What does plt.hist with alpha value 0.3 mean?
Alpha value of 0.3 means bars in histogram are somewhat transparent
Explain this code which produces a boxplot - (6)
- data = np.random.rand(1000,3) - produces 1000x3 Numpy array filled with random numbers between 0 and 1 with uniform distribution
data[:,1] = data[:,1]*2 + 1 - this multiples the second column of data array (all rows) by 2 and adds 1 to value - scales and shifts values in second column
data[:,2] = data[:,2]*1.5 +- 1 - this multiplties the values in the third column of data array by 1.5 and subtracts 1 from each value - shifts and scales values from third column
plt.figure() - produces figure for plot
plt.boxplot(data)- produces boxplot using data in data array - each column has a different dataet
plt.show() - displays plot with boxplot
What is output of the boxplot?
What does plt.xticks ([1,2,3], [‘Set1’, ‘Set2’,’Set3’])
Adds label for the 3 boxplots by setting first boxplot Set 1, second boxplot Set 2 and third boxplot is Set 3
We can change the plotting style using
plt.style.use() funtion
using
plt.style.use(‘ggplot’)
which shows:
We can change the plotting style using
plt.style.use() funtion
using
plt.style.use(‘fivethirtyeight’)
which shows:
Question 1
Consider the following code snippet:
What is wrong with this code? How should it be corrected?
Technically this might execute but the file_path is not an absolute path as expected. Almost certainly it is missing the initial ‘/’
Identify the problem in this code and suggest a fix. - (2)
The plt.show() command fixes the image so the last two lines do not do anything.
Place them before the plt.show() command.
This code makes an assumption - what is it? - (2)
It assumes there is at least one line of data in the file as well as the header.
If this it not true, it will throw an exception.
This code has a similar bug to that in Q2. What is it? - (2)
Again - the plt.show() command stops the next line from working.
Change their order.
How might this code run into problems depending on the platform it runs on?
The ‘directory’ variable hard-codes the ‘/’ separators. This might fail on Windows where the separator should be ‘'
This code is designed to plot two random time series. What mistake does it make? - (3)
Data is defined as a 2 (down) by 10 (across) array.
So it will plot 10 random time series with two points each.
Change to rand(10,2) to make it work.
Again, this code might work or it might not depending on the operating system, even if you are sure that the directory ‘plots’ exists. What line makes it so ‘fragile’ and how could you fix it? - (3)
Line of error - plt.savefig(‘/plots/parabola.png’)
Windows uses \ instead of /. - fix it by plt.savefig(‘\plots\parabola.png’)
Use os.path.join to glue together all the bits in a platform-independent manner.
Which one of these boxplots will have the highest median value (as indicated by the bar across the middle)? - (2)
A
The second one (‘Group 2’). The offset is defined by the +2. The spread is defined by the *.5. So this one will have a median at +2 which is bigger than any of the others.
This is because offset (+2) directly adds a constant value to each data point, it has a more significant impact on the median compared to the spread (*.5).
Q10
A directory contains the following files - (2)
a: apple.txt, allFruit.csv, allFruit.xls, allFruit.tsv, apple.jpg
b: apple.jpg, banana.jpg
Command that sees ‘filtered_func_data_MNI3MM.nii.gz
Summary of experiment used for nilearn - hand movement and visual grating
To summarise, our experiment involved the following timeline, shown for the first minute of the experiment. + in the table below means that the given stimulus is ‘on’.
What would our TSV file look like for our hand movement and visual grating experiment?
First step in producing TSV file for an experiment of hand duration and vision duration is that - (3)
We will use pandas to generate a nice structure to hold the information (a table with the names, onsets and durations)
Pandas can then write that table directly to disk.
. We will also define the hand and vision stimulus durations as variables at the start - Then, if we need to change them for some reason (perhaps to analyze another dataset) we only have to change those lines.
Second step of TSV
Constructing onset times for hand movement which said Constructing onset times for hand movement which said where the condition starts at 6 seconds into the experiment and alternates every 32 seconds. Each cycle consists of 16 seconds of activity followed by 16 seconds of rest. :
hand_duration = 16s
explaining this code - (2)
The ‘range()’ function is used to generate a list of onset times, starting at 6 and ending before 320 (the duration of the experiment), with a step size of ‘hand_duration * 2’.
Since ‘hand_duration’ is 16 seconds, ‘hand_duration * 2’ equals 32 seconds, ensuring the desired alternating pattern of 16s on and 16s off.
What would be output?
What would be output of this code?
Third step producing pandas dataframe
Explain the creation of the dataframe for the Hand Movement condition - (2)
We create a dataframe using Pandas from dictionary type key (value-pairs), where each row represents a trial of the Hand Movement condition.
The dataframe consists of three columns: ‘trial_type’, indicating the type of trial (hand_movement); ‘onset’, containing the onset times calculated previously; and ‘duration’, representing the duration of each hand movement trial (calculated hand_onset and hand_duration previously)
Third step producing pandas dataframe
Explain the creation of the dataframe for the Vision condition- (2)
Similar to the Hand Movement dataframe, we create a dataframe for the Vision condition.
Each row represents a trial of the Vision condition. The dataframe contains three columns: ‘trial_type’, indicating the type of trial (vision); ‘onset’, containing the onset times calculated previously; and ‘duration’, representing the duration of each vision trial.
Explain final step of constructing TSV - (9)
The final step involves combining the dataframes representing the Hand Movement and Vision conditions into a single dataframe named ‘conditions_df’.
This is achieved using the ‘pd.concat()’ function, which concatenates the two dataframes along their rows.
Once the dataframe is constructed, the next task is to save it as a TSV file.
For this purpose, a file path ‘tsv_path’ is defined, specifying the location and name of the TSV file to be created.
Then, the ‘to_csv()’ function is called on the ‘conditions_df’ dataframe.
This function writes the contents of the dataframe to a CSV file.
By setting the ‘sep’ parameter to ‘\t’, we specify that the file should be tab-separated, as required for a TSV file.
Additionally, ‘index=False’ is used to exclude row indices from the file.
This final step ensures that all trial information, including trial type, onset times, and durations, is saved into a properly formatted TSV file, ready to be used in further analysis.
When constructing the TSV file,
Note that although people often have the onsets roughly in chronological order in the stimulus file, this is not required. In principle, we can list all the motor stimuli, then all the vision stimuli.
Explain this code - plotting the timecourse of each condition - (6)
This code snippet begins by importing the necessary Python libraries: Pandas for data manipulation and Matplotlib for data visualization. It then proceeds to read a TSV (Tab-Separated Values) file containing trial information into a Pandas dataframe using ‘pd.read_csv()’, where the ‘\t’ (TAB) separator is specified to ensure proper parsing of the file.
Next, it defines the total duration of the experiment (320 seconds) and initializes two lists, ‘time_series[‘hand_movement’]’ and ‘time_series[‘vision’]’, with zeros. These lists will be used to represent the time courses for hand movement and vision conditions, respectively.
The code iterates through each row of the dataframe using the ‘iterrows()’ function, extracting the onset and duration of each event. For each event, it calculates the start and end time points.
Subsequently, it identifies the type of event (hand movement or vision) and updates the corresponding elements in the time series lists to 1, indicating the presence of the stimulus during the event’s duration.
Once the time series data is populated, it plots the time courses using Matplotlib. The x-axis represents time in seconds, while the y-axis indicates stimulus activity (0 for inactive and 1 for active). The plot visually represents the temporal patterns of stimulus presentation for both hand movement and vision conditions throughout the experiment.
Overall, this code snippet demonstrates how to read trial information from a TSV file, process the data to create time courses, and visualize the temporal dynamics of stimulus presentation during an fMRI experiment.
Compare the plot of the stimulus time course with the actual fMRI data - (6)
First produced from TSV and another using nibabel from data of time series of two voxels
The stimulus time course, represented by the plot in the previous flashcard, is more blocky and binary in nature, with values restricted to either 0 or 1 to indicate the presence or absence of the stimulus.
In contrast, the plot of the actual fMRI data depicts the time-series signals from two voxel positions within the brain (visual and motor cortex).
These signals exhibit more dynamic behavior, reflecting the complex hemodynamic response associated with neural activity.
The fMRI signals show fluctuations over time, influenced by various physiological and neurological factors.
The stimulus time course serves as a simplified representation of the experimental conditions, while the fMRI data provides a more detailed view of brain activity patterns in response to these conditions.
Before performing the General Linear Model (GLM) analysis, the stimulus time course is convolved with a hemodynamic response function (HRF) to simulate the expected fMRI response to the experimental stimuli.
We are going to use a slightly different fMRI data set that is aligned to MNI brain and going to load the image using nilearn:
Explain this code snippet:
- Imports the ‘image’ class from the nilearn library, which deals with fMRI data.
- Loads an fMRI dataset from the specified path using the ‘load_img’ function.
- Stores the loaded fMRI image in the variable ‘fmri_img’.
- Prints the shape of the loaded fMRI image, which includes information about its dimensions (e.g., number of TRs).
Explain output of this code snippet: (45,54,45,160)
so the volume size is slightly different: 45x54x45x160 (the size of one functional volume) but still 160 volumes long
We can also look at a single image from functional volume using nilearn from our functional data aligned to MNI brain by this code
explain it- (6)
Imports the ‘plotting’ module from nilearn, which contains functions for visualizing neuroimaging data.
- Imports the ‘image’ module from nilearn, which deals with loading and manipulating neuroimaging data.
- Selects the first volume (timepoint) of an fMRI image using ‘image.index_img’.
- Plots the selected volume using ‘plotting.plot_epi’, which displays one slice of the brain at one moment in time.
- Includes a color bar in the plot to indicate signal intensity.
- Displays the plotted image using ‘plotting.show()’.
What is output of this code and explain it - (6)
These are the raw EPI amplitudes for a single TR of fMRI data. You are not seeing the functional responses to the stimuli here - just the mean signal levels.
The functional signals are modulations of about 1% in the mean signal.
Notice that the amplitude of the signal drops from the outside to the inside of the brain.
This is driven by two things:
1: The BOLD amplitude is biggest in the gray matter (and the surface blood vessels).
2: The coils are most sensitive to things that are near them - and the centre of the brain is far away.
We can also load and plot T1 anatomical data using image from nilearn and plotting from nilearn as well
explain this code - (6)
- Imports the ‘image’ module from nilearn, which handles loading and manipulating neuroimaging data.
- Imports the ‘plotting’ module from nilearn, containing functions for visualizing neuroimaging data.
- Specifies the path to the anatomical (structural) MRI image file.
- Loads the anatomical image using ‘image.load_img’.
- Plots the loaded anatomical image using ‘plotting.plot_anat’.
- Displays the plotted anatomical image, providing a visual representation of the brain’s structure.
Output of this code
Can do analysis in Spyder by changing following.. and adding this code after loading one image from functional.. - (8)
subject_anat_path=’/pin-material/s7_fmri//highres.nii.gz’ # You have to change this bit
This code Creates an interactive HTML view of the specified fMRI image (‘first_TR’) using Nilearn’s ‘view_img’ function.
- Sets visualization parameters such as threshold (2000), maximum intensity value (vmax) of 30000, and coordinates for cutting planes.
- Specifies the title of the HTML view as “Raw fMRI”.
- Disables the background image using ‘bg_img=False’.
- Opens the interactive HTML view in a web browser using ‘html_view.open_in_browser()’. - allows to browse the data in web browser
- Allows interactive exploration of the fMRI data in the web browser, providing a convenient way to inspect the image with adjustable settings.
- Provides a note about the alternative approach of saving the data to disk and loading it using the nibabel library.
Building a first level-analysis model using GLM in nilearn
Explain this code - (6)
- Imports necessary modules from Nilearn for setting up and fitting a first-level General Linear Model (GLM) to functional MRI (fMRI) data.
- Loads event information from a TSV file into a pandas DataFrame, representing experimental conditions and timing.
- Loads fMRI data from a specified path using Nilearn’s load_img function.
- Determines the repetition time (TR) of the fMRI data, a crucial parameter in fMRI analysis.
- Sets up a FirstLevelModel object, specifying TR and high-pass filtering parameters for the GLM analysis.
- This code snippet prepares the necessary components for conducting a first-level analysis of fMRI data, including loading data, defining experimental conditions, and setting up the GLM model.
We have build a ‘first level model’ in nilearn. It is empty so far - we need to feed it with data but we can look at its parameters before we do that. - (3)
For example, by default it uses an estimate of the hemodynamic response function that is specified in an old paper from Gary Glover at Stanford:
We know this because we can ask about the hrf_model:
Here are the two main models you can use (‘SPM’, ‘glover’ - which are about the same) - plus another one (‘MION’) which is super-weird and used only for a special type of contrast agent.
Exlain what this code does feeding our first-level model with fMRI data - (3)
his code snippet fits the first-level GLM model to the fMRI data by calling the .fit member function of the FirstLevelModel object.
- The .fit function takes two main arguments: the fMRI data (fmri_img) and the events dataframe (events) containing experimental conditions and timing information.
- By calling .fit, the GLM analysis is performed, and the design matrix is built ‘on the fly’, meaning it is constructed dynamically during the fitting process.
After fitting fMRI data to GLM, we can access the design matrix:
Explain this code - (4)
- After fitting the first-level GLM model to the fMRI data, the design matrix can be accessed using the ‘design_matrices_’ attribute of the FirstLevelModel object.
- In this code snippet, the design matrix is obtained from the first element (index 0) of the list of design matrices.
- The design matrix represents the relationship between the experimental conditions (e.g., hand movement, vision) and the observed fMRI data, with each row typically corresponding to a time point (TR) and each column representing a different experimental condition or regressor.
- The design matrix is visualized using Nilearn’s plot_design_matrix function, providing insight into how the experimental design is encoded in the GLM analysis.
Output of this code
Explain this code producing contrasts of beta values obtained from GLM model - (5)
- This code snippet computes contrasts using the beta values obtained from the fitted first-level GLM model.
- Two contrast vectors,
contrast_motorandcontrast_vision, are created as numpy arrays of zeros, with the length equal to the number of columns in the design matrix. - A value of ‘1’ is set at the index corresponding to the trial type of interest in each contrast vector, allowing examination of the beta values associated with specific trial types.
- The
compute_contrastmethod of the FirstLevelModel object is then used to compute contrasts based on these vectors, producing beta maps for the specified trial types (motor and vision). - These beta maps provide information about the effect size of each trial type relative to the baseline or reference condition.
We have extracted the beta maps into two arrays. We have lots of options for plotting them. Here, for example is nilearn’s ‘mosaic’ option for plotting a stat_map
Explain the code - (6)
- This code snippet utilizes Nilearn’s
plot_stat_mapfunction to visualize the beta maps computed for the motor and vision stimuli. - Each
plot_stat_mapcall plots a beta map for a specific stimulus, with titles indicating the corresponding trial type (‘motor’ or ‘vision’). - The ‘mosaic’ option for the
display_modeparameter plots the beta maps in sagittal, coronal, and axial views simultaneously. - The
black_bg=Trueparameter sets the background color of the plot to black. - A threshold value of 0.25 is applied to display only voxels with absolute effect sizes greater than or equal to 0.25.
- The
plotting.show()function displays the plotted beta maps.
Output of this code
1: The data are automatically overlaid on an MNI brain. So we have lots of anatomical landmarks to help us see where we are. We can do this because we are using a version of the functional data that we have aligned to the MNI brain already (using FSL’s FLIRT command).
2: The subject was instructed to use their right hand to tap with. You might therefore expect to see motor cortex activity only on the left - but it’s present in both hemispheres (stronger on the left). I don’t know why this is but it is a common observation.
3: The visual stimulus flickered on the left side of the screen and this response is localized to the right hemisphere. That is what we expect from the strict retinotopy of the visual cortex.
4: You can see small regions in visual cortex that respond to both motor and vision stimuli. Again, not clear why - perhaps the motor activity was cued by a visual cue?
First step of doing first-level analysis in nilearn -overall:
from nilearn.plotting import plot_design_matrix
from nilearn.glm.first_level import FirstLevelModel
import numpy as np
import pandas as pd
- making TSV file - (6)
- This code snippet demonstrates the process of creating a TSV (Tab-Separated Values) file for defining experimental conditions and their timing in an fMRI experiment.
- It involves defining the paths for the fMRI data (
subject_data_path) and the TSV file (tsv_path). - Duration values for each stimulus block (
hand_durationandvision_duration) are specified in seconds. - Onset times for the ‘hand_movement’ and ‘vision’ conditions are generated using lists created with the
range()function, representing the start times of each stimulus block. - Dataframes (
hand_movement_dfandvision_df) are created for each condition, specifying columns such as ‘trial_type’, ‘onset’, and ‘duration’. - These dataframes are then concatenated into a single dataframe (
conditions_df) representing all experimental conditions. - Finally, the dataframe is saved to a TSV file (
tsv_path) using theto_csvmethod, with ‘\t’ as the separator andindex=Falseto omit row indices.
Second step of doing first-level analysis in nilearn -overall:
loading fMRI data and TSV file and do GLM
(9)
- This code snippet continues the analysis process after creating the TSV file and loading fMRI data.
- The TSV file containing experimental conditions and timing information is loaded into a pandas DataFrame (
events) usingpd.read_table. - Functional MRI (fMRI) data is loaded from the specified path (
subject_data_path) using Nilearn’sload_imgfunction. - The repetition time (TR) of the fMRI data is determined either directly or from the image header.
- A
FirstLevelModelobject is instantiated to set up the first-level GLM analysis, specifying parameters such as TR and high-pass filtering. - The GLM model is fitted to the fMRI data using the
fitmethod of theFirstLevelModelobject, with the events DataFrame supplied as input. - The design matrix of the fitted GLM model is obtained from the
design_matrices_attribute. - Contrasts are defined and computed using the
compute_contrastmethod of theFirstLevelModelobject, producing beta maps for specific stimuli. - Finally, beta maps for motor and vision stimuli are visualized using Nilearn’s
plot_stat_mapfunction, with the ‘mosaic’ display mode.
Q1
I am using nilearn to run a GLM on a nifti file fmri_img.
I have generated a events structure events already from a .tsv file output while the scan ran. The scanner collected individual data volumes (64x64 inplane resolution, 40 slices) once every 3s. The code I am running to perform the GLM is this:
The code runs but the resulting contrast maps seem to show only noise. I was expecting a large and reliable effect and it is not there. What error have I have made?
The TR of the stimulus was 3s but you have specified it as 5s in the model.
Q2
I am generating a .TSV file to store timing information for a nilearn analysis. The experiment had two visual stimuli: one on the left and one on the right. On the left, the first stimulus appeared at 6s and the stimulus duration was 10s. On the right the offset was 0s and the duration was 12s. The TR of the experiment was 2s and the scanner ran for 160 TRs.
Part of the TSV generation code looks like this:
The durations have been specified in TRs but they should be in seconds. They are therefore half as long as they should be.
Explain what will happen in overall experiment - (3)
For the left visual flicker condition:
- The stimuli start appearing at 6 seconds into the experiment and alternate every 24 seconds (12 blocks), with 12 seconds of flickering followed by 12 seconds without flickering.
For the right visual flicker condition:
- The stimuli start appearing immediately at the beginning of the experiment (0 seconds) and alternate every 24 seconds (12 blocks), with 12 seconds of flickering followed by 12 seconds without flickering.
The stimulus on th left lags that on the right by 6s.
Q4
I am about to start an analysis using nilearn. I run this code but get error message
What has probably gone wrong and how do I fix it?
You have not installed the ‘nilearn’ module. Use pip install nilearn to install it.
To install MNE on Google Colab or Windows/Spyder machines, we enter:
To install MNE on Spyder, you type this (‘pip install mne’) on the - (2)
in the terminal to the bottom right.
Remember to ‘restart kernel’ after you do this. You might also have to set the Graphics output type to ‘QT - to ensure plots in Spyder are interactive
MEG data come in a variety of formats. Most of the existing data which is available at YNiC is from a
4-D system like this:
All the file paths in this section is relative to s8_meg directory in the material directory, so need to change the directory you are working in Spyder or replace the full paths such as.. C:\Users\gs1211\ . . .
This code is saying that:
This code fetches a specific branch (s8_meg) from a Git repository (https://vcs.ynic.york.ac.uk/cn/pin-material.git) and clones it into the current directory
We can check git repository is there by saying:
This command lists the contents of the directory s8_meg within the pin-material directory, showing details such as permissions, ownership, size, and modification time, with the most recently modified files appearing first.
First we want to change the directory where s8_meg live by saying the following code - (2):
This code imports the Python libraries ‘os’ and ‘mne’.
Then, it changes the current working directory to ‘/content/pin-material/s8_meg/’ using the ‘os.chdir()’ function.
What is the purpose of the following code snippet?
This code reads MEG data from a file and extracts different parts of the MEG dataset for analysis.
What is output of
raw = mne.io.read_raw_bti(‘./R1025_P1119a_4/c,rfDC’
print(raw)
Outputting
print(raw.info)
raw - loaded mne data
What does this output show of raw.info? - (7)
Going from top to bottom, we can see that at present there are no bads set: i.e. we have not configured bad channels yet.
There is a list of channel names in the ch_list attribute, and the chs attribute is actually a list of all channel details; when printed, it simply shows a summary of what types of channels we have.
On our MEG system system, the main MEG channels are referred to as A1 to A248. When loading the data into MNE, these are mapped into MEG 001 to MEG 248; the reference channels are also remapped in the same way. We therefore need to remember to refer to the channel names in the way that MNE expects.
The next few lines refer to the transform which is calculated based on the “Coil-on-Head” calculations and the movement into the standard space that MNE uses: we ignore this for now.
Under dig, we see that we have 1558 digitisation points: these come from the Polhemus head digitisation system which is used with the 4D MEG scanner.
We can also see that the data were filtered between 0 and 339.1Hz.
We then get some information about the date of the scan, the total number of channels and then the sfreq: the sampling frequency.
What does this following code snippet do? - (4)
Accessing the keys in the raw.info structure
This code snippet extracts digitisation data from the MEG dataset, storing it in a variable named ‘dig’.
It then prints the type of data contained in ‘dig’ and displays the first few elements of the digitisation data, providing insight into the location of critical head structures.
Finally, it prints the total number of elements in the digitisation data.
What does the line dig = raw.info['dig'] accomplish? - (2)
This line extracts digitisation data from the MEG dataset, specifically the set of 3D points in space that indicate the location of critical head structures. I
t stores this data in a variable named ‘dig’.
What does the code print(type(dig)) do?
The code print(type(dig)) prints the type of data contained in the variable ‘dig’, which is <class ‘list’>
What information does the line print(dig[0:5]) provide? - (2)
The line print(dig[0:5]) displays the first five elements of the digitisation data stored in the variable ‘dig’.
These elements represent 3D points indicating critical head structures, such as the nasion and inion as well as extra points when the stylus stroked the head structure
What does the code print(len(dig)) show?
The code print(len(dig)) prints the total number of elements in the digitisation data, providing insight into the overall size
Explain the output - (3)
[<DigPoint | LPA : (-74.6, 0.0, 0.0) mm, ….., Extra #2 : (-19.5, 66.3, 39.6) mm…]
We see that the digitisation points are stored as a list of objects of type DigPoint.
If we want to plot these data, we will need to extract them.
We see that the first three are different to the rest which seem to be called Extra X.
Those first three points define the coordinate system and although they are both interesting and useful, we don´t need them right now. Instead we will focus on the Éxtra’points which contain the shape of the head.
What does the code ex_1 = dig[3] do? - (2)
The code ex_1 = dig[3] extracts a digitisation point from the digitisation data stored in the variable ‘dig’.
Specifically, it selects the digitisation point after the first three points and assigns it to the variable ‘ex_1’.
What does the code print(type(ex_1)) reveal?
The code print(type(ex_1)) prints the class of the object stored in the variable ‘ex_1’, indicating that it belongs to the class mne_fiff.digitisation.DigPoint, representing a digitisation point.
What does the code print(dir(ex_1)) accomplish? - (2)
The code print(dir(ex_1)) lists all methods and attributes associated with the digitisation point stored in the variable ‘ex_1’.
However, the output can be cluttered, making it difficult to discern relevant information.
What does ([x for x in dir(ex_1) if not x.startswith(‘_’)]) do? - (2)
The code [x for x in dir(ex_1) if not x.startswith('_')] produces a cleaner version of the list by filtering out methods and attributes that start with an underscore (‘_’).
This list comprehension generates a new list containing only the methods and attributes accessible for the digitisation point, making it easier to navigate.
These are all
lot of private methods (things which start with an underscore “_something”) which clutter up our view, so we decide to exclude them using a list comprehension.
What does this code do? - (2)
- It first prints the data type (
float) and the value of the sampling frequency (sfreq) associated with the MEG data. - Then, it prints the data type (
list) and the list of channel names (ch_names) in the MEG data.
Output of this code
What does the code print(ex_1.keys()) accomplish?
The code print(ex_1.keys()) prints out the keys associated with the digitisation point ex_1,
What is the purpose of the following code snippet? - (2)
The purpose of this code snippet is to extract digitisation points from the ‘digitisation’ data stored in the variable ‘dig’.
It specifically selects points originating from the Polhemus device and stores their coordinates in a numpy array.
What does the line if pt['kind'] == mne.io.constants.FIFF.FIFFV_POINT_EXTRA: check for? - (2)
The line if pt['kind'] == mne.io.constants.FIFF.FIFFV_POINT_EXTRA: checks whether a digitisation point is of the type ‘FIFFV_POINT_EXTRA’, indicating that it originated from the Polhemus device.
These are the types (or ‘kind’) of things we want! They are ‘extra’ because they come from the Polhemus and not the scanner hardware itself.
What does the code out_pts.append(pt['r']) accomplish?
The code out_pts.append(pt['r']) extracts the coordinates of digitisation points in a tuple of (x,y,z) originating from the Polhemus device and appends them to a list called ‘out_pts’. - specifcying location of digitsation point in 3D space
What does the line print(f'Here are the dimensions of the point array: {out_pts.shape}') display? - (3)
prints the dimensions of the numpy array containing the digitisation points.
Here are the dimensions of the point array: (1555, 3)
So, we finish with 1555 Polhemus points. We started (back in the info structure) with 1558 points, and found that 3 of them were “cardinal points”, so this makes sense.
What does this code do?- - (3)
This code snippet utilizes numpy and matplotlib to create a 3D scatter plot of digitisation points stored in the numpy array ‘out_pts’.
It first creates a figure and an axis with 3D projection, extracts the x, y, and z coordinates from ‘out_pts’, and then plots these points as a scatter plot in 3D space using the ‘scatter’ function.
Finally, it displays the plot.
Output of this code
At this point we want to interact with the plot - maybe use spyder but we can do 3D plotting in the browser like this:
Code:
import plotly.express as px
fig = px.scatter_3d(x=x, y=y, z=z, opacity=.5)
fig.show()
What does this code do? - (3)
This code snippet uses Plotly Express to create a 3D interactive scatter plot.
It takes the x, y, and z coordinates of the points and creates a 3D scatter plot with a specified opacity level.
The fig.show() function then displays the interactive plot.
What does this code do? - (2)
This code snippet uses Plotly Graph Objects to render a surface plot.
It creates a mesh plot using the x, y, and z coordinates of the points, setting the color to gray and opacity to 1.
The fig.show() function then displays the rendered surface plot.
What does the code raw.plot_sensors(kind='3d')
plt.show() do? - (3)
This code utilizes the plot_sensors function from the MNE library to create a 3D plot showing the relative positions of all sensors in the MEG data.
Each sensor’s position is represented in three dimensions.
What does the code raw.plot_sensors() do?
plt.show() - (2)
This code uses the plot_sensors function from the MNE library to create a 2D plot showing the relative positions of all sensors in the MEG data.
Each sensor’s position is represented in two dimensions.
What library is imported with the statement from matplotlib import figure?
The statement from matplotlib import figure imports the figure module from the Matplotlib library. This module provides the functionality to create and customize figures for plotting.
What does the code raw.plot() do? - (2)
The code raw.plot() utilizes core routines from the MNE library to create a plot showing the raw MEG data.
This plot displays the burst of energy detected by each sensor across time, providing an overview of the MEG data.
What observation is made about the behavior of raw.plot() on certain platforms like Colab?
On certain platforms like Colab, the interactive window might be plotted twice when using raw.plot(), and it may not be interactive as expected.
What does the comment “# producing the burst of energy of heart at every sensor across time - something we would want to remove” suggest about the plot generated by raw.plot()? -(2)
The comment suggests that the plot generated by raw.plot()displays cardiac artefacts - not part of brain and the part of heart
These artifacts are undesirable and may need to be removed from the data.
Also see very fast ripples which are called line noise- noise coming from electromagnetic enviroment e.g., light from MEG room and taket them out as well
What does the code raw.pick_types(meg=True).plot(butterfly=True) accomplish?
raw.pick_types(meg=True).plot(butterfly=True) selects only the MEG channels from the raw data and plots them in a ‘butterfly’ format
In the butterfly plot, each channel’s signal is displayed along a single line, allowing for easy comparison of signals across channels
This format is particularly useful for visualizing MEG data, as it helps to identify patterns and abnormalities in the signals.
What observation is made about the noise in the data shown below the code snippet? - (2)
The comment suggests that there is a significant amount of noise present in the data shown below the code snippet.
This noise can obscure the underlying signal and may need to be filtered or removed for further analysis.
How do you plot 1 second of MEG data starting at 6 seconds using the raw.plot() function? - (2)
To plot 1 second of MEG data starting at 6 seconds, use the start and duration options in the raw.plot() function:
raw.plot(start=6, duration=1). This will zoom in to display a short, specific segment of the data.
What does raw.plot(start=6, duration=1) plot? - (2)
plots a standard time series of the MEG data for all selected channels, showing the data from the 6th second to the 7th second.
Each channel’s data is displayed separately, rather than overlaid as in a butterfly plot
What effect does plotting 1 second of data starting at 6 seconds have on the visualization? - (2)
Plotting 1 second of data starting at 6 seconds zooms in on a short, specific segment of the data, allowing for finer detail to be seen.
This can help in identifying and analyzing individual events, such as heartbeats picked up by a single sensor.
What is the purpose of the following code snippet in the context of MEG data analysis?
This code snippet isolates the trigger (stimulus) channels from the raw MEG dataset, prints the names of the remaining channels, and plots the trigger channel over a duration of 60 seconds to visualize the event trace.
What does the output of this code show? - (2)
The typical output would display the names of the channels present in the trig_chan dataset, such as “STI 014” and “STI 013”.
Additionally, it would show a plot of the trigger channel over a duration of 60 seconds, with the x-axis representing time (in seconds) and the y-axis indicating the presence of trigger events.
Each line on the plot corresponds to a different trigger event recorded in the MEG data.
How can you explicitly make a copy of a list or dataset in Python? - (2)
To explicitly make a copy of a list or dataset in Python, you can use the .copy() method/statement.
For example:
This ensures that b is a separate copy of a, allowing independent modifications without affecting the original list or dataset.
What does the shape (600, 3) of the events array indicate? - (2)
The shape (600, 3) of the events array indicates that there are 600 events detected in the dataset.
Each event is represented by three pieces of information: the start index in time, an irrelevant column (not used), and the event code.
What does the event code 4196 signify in the context of the MNE-Python dataset? - (2)
In the context of the MNE-Python dataset, the event code 4196 represents a specific type of event or trigger recorded in the data.
It could correspond to a particular stimulus presentation, experimental condition, or other predefined event in the experimental paradigm.
What does the event_dict = {‘visual’: 4196} line of code accomplish? - (2)
The event_dict = {‘visual’: 4196} line creates a dictionary that maps descriptive names (‘visual’) to event codes (‘4196’).
This allows for more intuitive labeling of triggers in the plot.
What does the plt.figure(figsize=(15,3)) line of code do? - (2)
The plt.figure(figsize=(15,3)) line sets the size of the figure for plotting events.
It specifies a figure size of 15 inches in width and 3 inches in height, ensuring appropriate visualization.
What does the mne.viz.plot_events(events, sfreq=raw.info[‘sfreq’], event_id=event_dict, axes=h) function call do? - (2)
The mne.viz.plot_events() function plots the time-series of events.
It takes the events data, the sampling frequency (sfreq), the event dictionary (event_dict) for labeling, and the axes (axes=h) for plotting.
What does output of this code show? - (4)
pot the time-series of events. We see that there were some gaps in events, presumably to give the participant a short break.
. Each line corresponds to a specific event ID, in this case, ‘4196’. These lines are spaced apart with gaps indicating periods where no trigger events occurred.
Bunch of them up to 110s then a gap…
Participant se flash on screen then a gap and then flash
What does the blue lines represent when plotting the original data with events marked on?| - (2)
The blue lines represent the events marked on the plot.
Each line corresponds to a specific event, and the position along the time axis indicates the timing of the event occurrence.
What does the plot() function do in the context of meg_chan.plot(butterfly=True, clipping=None,start=100,duration=1)?
It plots the MEG data in a butterfly format, where each sensor’s data is represented on a separate line for better visualization.
What does the random_state=97 parameter in the ICA instantiation achieve?
It ensures reproducibility of the ICA decomposition across different runs of the algorithm, which is particularly useful for teaching purposes or when consistency in results is desired.
What does the output “Filtering raw data in 1 contiguous segment” indicate?
It indicates that the raw data is being filtered to remove very slow components, such as drifts, before applying ICA.
How many ICA components were requested in the code?
Fifteen ICA components were requested by setting n_components=15 in the ICA instantiation.
does it do low or high apss fitlering in this code?: - (2)
This code performs high-pass filtering. This is evident from the parameter l_freq=1 in the filter method, which specifies the lower frequency cutoff for the high-pass filter.
The absence of h_freq parameter means there is no upper frequency cutoff, indicating that only high-pass filtering is applied.
What is the low-frequency cutoff? - (2)
The low-frequency cutoff is 1 Hz. This is specified by the parameter l_freq=1 in the filter method.
By applying a high-pass filter with a cutoff frequency of 1 Hz, it removes very slow components, such as drifts, from the data
Output of ica.plot_components() explained: (2)
We are looking for artifacts coming from two places: Eye movements (which will show up either side of the front of the head) and cardiac (heartbeat) artifacts which come from far far away and so might just smear out over the whole brain.
We are immediately suspicious of components ICA000 looks like it originates very low down in the brain…. sources like this could be real data from deep brain structures but often they are actually interference from the electrical activity of the heart (which is firing a big ‘pulse’ every second or so). 0005 is pretty much centred on the eyes… TBH I’m not excited about 0002 either but let’s take a look…
What does the function ica.plot_sources(raw, show_scrollbars=False) do?
It visualizes the timecourse of the sources identified by ICA, allowing us to inspect potential artefacts such as cardiac activity, eye movements, or breathing patterns.
What does it indicate if a component isolates a cardiac-style trace? e.g., , ICA000 looks like it has isolated a cardiac-style trace.
t suggests that the component may be capturing electrical activity related to the heartbeat, which is considered an artefact in MEG and EEG data analysis.
How can we identify potential artefacts such as eye movements or breathing patterns in the timecourse of the sources?
By visually inspecting the traces generated by ica.plot_sources(), we can observe characteristic patterns that resemble known artefacts, such as rapid fluctuations indicative of eye movements or periodic patterns corresponding to breathing.
ICA005 also appears to have isolated something which may be eye movement. Looking at the traces, however, it is also possible that ICA006 has done the same. ICA010 also appears to be some form of breathing artefact.
Which components are decided to be removed in this case, and why?
Components 0, 5, 6, and 10 are marked for removal as they appear to isolate artefacts such as cardiac activity, eye movements, or breathing patterns, which we aim to eliminate from the data.
What does ica.plot_sources(raw, show_scrollbars=False) accomplish? - (2)
This function plots the time series of the sources for each Independent Component identified by ICA.
By visualizing the timecourse of each component, analysts can identify artefactual patterns such as cardiac activity or eye movements for further inspection and potential removal.
What does the following code snippet do? - (2)
raw.load_data()
ica.plot_overlay(raw, picks=’meg’)
This code snippet loads the original raw data and then overlays the cleaned signals obtained after removing the specified Independent Components (ICs) onto the original signals.
It allows for a visual comparison between the original data and the cleaned data, highlighting the impact of IC removal on specific channels.
What does the following code snippet - (3) accomplish?
This code snippet applies the Independent Components Analysis (ICA) cleaning process to the copied raw data.
The original raw data remains unchanged, while the cleaned data is stored in the reconst_raw variable.
This allows for the comparison between the original and cleaned datasets, preserving the integrity of the original data.
What does the following code snippet do, and what does the resulting visualization show? - (5)
This code snippet compares the original raw dataset (raw) with the dataset after Independent Components Analysis (ICA) de-noising (reconst_raw).
It selects specific MEG channels specified in the chans list and plots their data side by side.
The visualization titled “Original” displays the raw data, while the visualization titled “Cleaned” displays the data after ICA de-noising.
By comparing the two plots, users can observe the effects of the de-noising process, such as the removal of regular cardiac artifacts and eye movements, as well as any potential loss of variance in the data.
Above is the original raw dataset and below is the dataset after ICA de-noising. You can see that we have removed the regular cardiac artefacts and we have also removed some eye movements (see around 6s in channels 153 and 154).
What is the purpose of deleting the original raw data (raw) using del raw? - (2)
Deleting the original raw data (raw) using del raw frees up memory resources by removing the data from memory.
This step is taken after the ICA de-noising process to ensure that memory is efficiently managed, especially if the dataset is large.
How is the ICA de-noised data saved in the provided code snippet? - (3)
The ICA de-noised data is saved to disk in compressed FIFF format using the save() method.
The filename used for saving the data is ‘R1025_P1114_4-raw.fif.gz’.
This ensures that the cleaned data is preserved and can be easily accessed in future sessions.
What function can be used to load the saved ICA de-noised data back into memory in future sessions? - ((3)
The mne.io.read_raw_fif() function can be used to load the saved ICA de-noised data back into memory in future sessions.
This function takes the filename of the saved data (‘R1025_P1114_4-raw.fif.gz’) as an argument and returns the data as a raw objec
However, it’s important to note that event timings and other related computations may need to be recomputed after loading the data.
What is the purpose of filtering the data between 3 and 30Hz? - (2)
Filtering the data between 3 and 30Hz helps isolate the frequency band associated with evoked activity, which is the focus of the subsequent analysis.
This filtering step removes high-frequency noise and low-frequency drifts, enhancing the signal-to-noise ratio for further analysis.
What precaution is taken before filtering the data? (3 Hz to 30 Hz) - (2)
Before filtering the data, the load_data() method is called to ensure that the data is loaded into memory.
This step is essential, especially when the file has just been re-loaded, to ensure that the data is available for filtering.
What filtering options are used in the provided code snippet? - (2)
A band-pass filter between 3 and 30Hz is applied to the data using an Finite Impulse Response (FIR) filter.
This filter selectively allows frequencies within the specified range to pass through while attenuating frequencies outside the range.
How can the original and filtered data be plotted for comparison? - (2)
Both the original and filtered data can be plotted using the plot() method.
For the original data, raw.plot(start=6, duration=2) is used, while for the filtered data, filt.plot(start=6, duration=2) is used.
This allows visual inspection of the effects of filtering on the data.
Explain the code - (7) - epoching the MEG data
This code epochs the filtered data using MNE.
filt: Filtered data to be epoched.
events: Event timings extracted from the filtered data.
event_id: Dictionary mapping event labels to event codes.
tmin: Start time of each epoch relative to event onset (-0.2 seconds).
tmax: End time of each epoch relative to event onset (0.5 seconds).
preload: Indicates whether to load all data into memory at once (True).
What does the output of filt_epochs represent?
We have 600 trials (as expected) and each of our epochs runs from -0.2 to 0.5s.
What does filt_avg.plot() visualize?
The average time-series of epochs with spatial colors and global field power (GFP), allowing for topology plots of sensors.
What does filt_avg.plot_topomap() display?
Topomap plots of sensor spatial distribution at specific time points, indicating brain activity patterns.
What does the output show? - (5)
The initial plot will show the average time-series.
Outside the notebooks, you can click and drag on this plot to draw a topology plot of the sensors over a given time-window.
The example above shows this for the first real peak (just before 100ms).
We can see from this that there is a right-lateralised dipole over where we would assume that occipital cortex would be.
This experiment involved showing a visual stimulus to the left-hand visual field, so this is somewhat reassuring.
What does filt_avg.plot_joint() visualize?
A combined plot showing the average time-series, topomap plots, and sensor data along with spatial distribution at specific time points.
How can you override the default times in filt_avg.plot_joint()?
By specifying the times argument, like filt_avg.plot_joint(times=[0.08, 0.31]).
Obtaining the data files needed for this lecture which is found in s7_fMRI directory by running this code:
What does this code mean?
git is accessing remote reposities and borrows data from YNiC (s7_fMRI directory) to local content directory
Output of this code:
After running the code:
We can check the current working directory
List the contents inside the current working directory
List what is inside pin-materials and s7_fMRI
What are these files when listening what is inside s7_fMRI? (last part) - (4)
These are all data files
‘highres.nii.gz’ is a anatomical file - 3D high-resolution structural image (T1) of someone’s brain
‘highres_brain.nii.gz’ - word brain means we have stripped away the skull and just looking at the brain (skull-stripped image of the brain) - using FSL command called BET
There are two functional imaging data files here/datasets which are 3D snapshots of the brain taken every 2 seconds (TR) while its doing a task: 1) filtered_func_data.nii.gz and func_data.nii.gz
Let’s move into the s7_fMRI which contains ‘highres.nii.gz’ directory for rest of tutorial by doing this which means
This code changes the current working directory to ‘/content/pin-material/s7_fmri’
So we are going to examine the ‘highres.nii.gz’ by loading it using nibabel
Thus, we need to import the module first:
This is common practice, analogous to importing numpy as np.
We will now use nibabel to load an fMRI file into Python and examine it of ‘highres.nii.gz’ using nibabel:
After using nibabel nib.load to load the structural NIFITI file (‘highres.nii.gz’) we can check the type of object returned by file and what type of object is returned which prints out…
this prints out: <class ‘nibabel.nifti1.Nifti1Image’>
We can also make a variable and store header info using anatImage.header and check its type which prints out…
this prints out:
We can also look at the keys of the header using
this print(hdr.leys()) is - (2)
This code prints out the keys present in the header of a NIFTI file.
Think of these keys as analogous to columns in a table. They provide information about various attributes and properties of the NIFTI image data.
The output of this code is
Explain this output:
These are all the stuff you would acquire as you run the MRI scanner such as extent of the data, how big the head was, what is sequence is, how tiny voxels are, coverage of brain, how was imaging planes oriented to acquire data
There are many items in the header but we are interested in
dim and pixdim entries
We can also look at the dim entries in which treating header like a dictionary and requesting ‘dim’ key from it using
print(hdr[‘dim’]) and see as output
What does this mean from print(hdr[‘dim’]) - (3)
When we look at dim, we find an array of integers
The 0th element (3 in this case) refers to how many dimensions of data there are; as this is a structural or anatomical dataset, there are 3-dimensions.
The remaining values tell us the number of voxels in each of the dimensions. As we only have three dimensions, only elements 1 to 3 (inclusive) have any meaning; the rest can be ignored.
When we show pixel dimensions header print(hdr[‘pixdim’]) - explain - (6)
In this code snippet, we’re accessing the ‘pixdim’ header in the NIFTI file, which provides information about the size of each voxel in millimeters.
These numbers are floats because they refer to the size in mm:
The printed array, [1. 1. 1. 1. 2.3 0. 0. 0.], contains float values representing voxel sizes.
Positions 1 to 3 (1.0) are relevant, indicating the voxel sizes in each dimension.
In this example, the numbers are all 1.0 which makes sense because the voxel sizes are 1mm in all dimensions
Additionally, the value in position 4 (2.3) refers to the ‘repetition time’ (TR) of the image, which might be relevant depending on the type of MRI data.
More detail on this output - (2)
We have taken 176 slices in sagittal plane/direction (going through middle of brain)
Each sagittal section is 256 by 256 voxels
Explain this output in more detail - (5)
Position 1: Width of the image in mm.
Position 2: Height of the image in mm.
Position 3: Depth or slice thickness of the image in mm.
For example, if positions 1 to 3 contain [1.0, 1.0, 1.0], it indicates that each voxel (3D pixel) in the image is 1mm x 1mm x 1mm in size.
So, if we’re considering the array [1. 1. 1. 1. 2.3 0. 0. 0.], positions are typically indexed starting from 0.
Next, we can load the actual image data of ‘highres.nii.gz’ using nib.looad instead of its header
Explain this code - (7)
import nibabel as nib: Importing the Nibabel library, used for reading and working with neuroimaging data.
anatImage = nib.load(‘highres.nii.gz’)`: Loading a structural NIFTI image from a file called ‘highres.nii.gz’.
data = anatImage.get_fdata(): Extracting the data from the loaded NIFTI image, storing it as floating-point numbers.
print(data.shape)`: Printing the dimensions of the data array, indicating the size of the image - (176 by 256 by 256)
print(data.dtype)`: Printing the data type of the elements in the data array, indicating they are floating-point numbers - float64
print(data[88, 127, 127]): Printing the value of a voxel located at coordinates (88, 127, 127) within the image. - 274.0 - saying how big the voxel is
print(data[1, 1, 1])`: Printing the value of a voxel located at coordinates (1, 1, 1), typically near the edge of the image (more likely to be small number as most black space near the head) - 4.0
Output of this code
Code producing one slice of data instead of one voxel
Explain this code - (4)
import matplotlib.pyplot as plt: Importing the Matplotlib library for visualization.
aSlice = data[124,:,:]: Extracting a single sagittal slice of brain data from a 3D volume stored in the variable ‘data’. This slice is located at index 124 (pass midpoint off the edge) along the first axis, which typically represents the sagittal plane (out of 176 slices) if we say index 88 its more or else down the middle
plt.grid(True): Configuring the plot to display grid lines for better visualization.
- plt.imshow(aSlice)
: Displaying the extracted sagittal slice using Matplotlib'simshow()` function, which visualizes a 2D array as an image. In this case, it displays the 2D slice of brain data.
Output of this code:
First of all the output of this is messy as it
t is standing up on its nose and the colour map is weird.
We can then load the data again
To change the colour map of the output - (2)
We can do this
plt.imshow(slc, cmap=’gray’) - # change colour map to grey
What does this code mean in more detail? - (6)
take 124 elemens through one dimension, : take every row and column through 124 slices of the head
We pick slice 124
The dimensions here (see Advanced material below) are
L-R, P-A and I-S
Slice 124 from the first dimension is more or less through the middle of the right hemisphere
The remaining dimensions are P-A and I-S
What does this output display - white stuff and grey stuff - (2)
- white stuff is fat
- grey stuff is neurons - convey communication between different parts of grey matter
Highlight positions on the head
We would like to flip the image the right way around - (3)
plt.show() then using tranpose function which takes a data set and spins it around the axis - it swaprs the dimensions so swaps vertical and horizontal axis
It would need anterior and posterior running along x axis - be upside down
so to fix then take that slice and resample in opposite direction [::-1,:] - pick all rows and columns but pick them in reverse order
Flipping image on right way around - first tranpose
What does this code do first? - (7)
It selects a single slice (slc) from the 3D brain data (data), specifically the slice at index 124 along the first axis.
It plots the selected slice using plt.imshow() with a grayscale colormap (cmap=’gray’).
It adds a title ‘Original’ to the plot.
It displays the plot using plt.show().
After plotting the original slice, the code recognizes that the image orientation needs adjustment for proper display.
It transposes the dimensions of the slice (slc.transpose(1, 0)) to swap the axes, changing the orientation from [I-S, P-A] to [P-A, I-S].
It plots the transposed slice using plt.imshow() with the same grayscale colormap.
After tranposing we need to reverse the image
Explain the reverse part - (7)
Remember how we can use the -1 operator to reverse the order in which we choose numbers from a list? - resample to opposite direction so all row and columns to minus 1
list[<start>:<stop>:<step>]</step></stop></start>
if you leave out an argument it just assumes ‘the start’ or ‘the end’ or ‘1’
So slc[::-1,:] means ‘I want the 2D matrix from slc but give me the first dimension (the rows) stepping ‘backwards’ in steps of 1,
and then leave the other dimension (the columns) unchanged’
his operation effectively flips the image vertically, changing the orientation from inferior-superior (I-S) to superior-inferior (S-I).
remeber dimensions are : # L-R, P-A and I-S
Explain rest of this code: after tranposing we want to we would like to have the axes labelled correctly in mm.
# So we need to know how big
# the image is on each side. That is found from the header:
# pixelSize * numberOfPixels - (8)
ap_npix = anatData.header[‘dim’][2]`: Retrieves the number of pixels along the anterior-posterior (A-P) direction from the image header.
-
si_npix = anatData.header['dim'][3]: Retrieves the number of pixels along the inferior-superior (I-S) direction from the image header. -
ap_pixdim = anatData.header['pixdim'][2]: Retrieves the pixel dimensions (in millimeters) along the A-P direction from the image header. -
si_pixdim = anatData.header['pixdim'][3]: Retrieves the pixel dimensions (in millimeters) along the I-S direction from the image header. -
Setting Image Extent:
-
extent = (0, si_npix*si_pixdim, 0, ap_npix*ap_pixdim): Calculates the extent parameter for the image plot, which defines the spatial dimensions in millimeters. It specifies the extent of the image along the x-axis (I-S) and y-axis (A-P) based on the number of pixels and pixel dimensions.
-
-
Plotting the Image:
-
plt.imshow(slc, cmap='gray', extent=extent): Plots the image (slc) using Matplotlib’simshow()function with a grayscale colormap (cmap='gray') and the calculated extent parameter. This ensures correct scaling and spatial representation of the image in millimeters. -
plt.title('Final image'): Sets the title of the plot to ‘Final image’ usingplt.title(). -
plt.show(): Displays the final image plot.
-
Output after tranposing, reversing and setting image extent:
The dimensions of our image are: [L-R, P-A, I-S]. We have taken a single slice in the left-right direction which means that we are left with data which is [P-A, I-S].
We are using the matplotlib imshow() routine whch
This takes data as if it were a photograph, i.e. the bottom left hand entry in our data matrix will be at the bottom left of the displayed image.
More detail what does transpose do and reverse? - (3)
At present, we have [P-A, I-S], so we start by using the .transpose() function to reverse the orders of the axes, ending up with [I-S, P-A].
This looks nearly right, except that we want our data in row 0 to be the most superior data and the data in the last row (255) to be the most inferior: i.e. our I-S axis needs to be S-I.
To do this, we just reverse the data in that dimension using the ::-1 syntax`(see below).
What does plt.show() and extent() do near end of code? - (7)
Now that we have re-ordered our data, we can pass it to imshow().
In the imshow() call, we use an extra argument which we have not seen before: extent.
This allows us to set the pixel dimensions for the image.
This is not actually that important in this case because the MRI image pixel size is 1x1mm, so it makes no difference.
If, however, your image was 1.13x1mm or similar, you would end up with a distorted image if you do not make this correction.
What we do is to multiply the number of pixels in each dimension by the size of the pixels in that dimension.
This makes matplotlib scale the image properly.
What does red plot do near end of code?
To show off, we also show that we can plot points on the same plot - so, we add a red point at a specific point on the image; we could also add text, arrows and anything else which we can do in matplotlib.
Explain this part of the code that tranposes and reverses brain image NIFTI file that it got to right orientation - (18)
-
Loading Data:
-
import os: Imports the os module to interact with the operating system. -
import nibabel as nib: Imports the nibabel library for working with neuroimaging data. -
import matplotlib.pyplot as plt: Imports the matplotlib library for plotting. -
os.chdir('/content/pin-material/s7_fmri'): Changes the current working directory to ‘/content/pin-material/s7_fmri’. -
s = nib.load('highres.nii.gz'): Loads the structural NIFTI file named ‘highres.nii.gz’. -
data = s.get_fdata(): Loads the image data from the NIFTI file as floating point numbers.
-
-
Plotting Original Slice:
-
slc = data[:, :, 100]: The syntax [:, :, 100] selects all rows and columns (full 2D slice) at the specific index 100 along the third axis (I-S direction) of the data volume. -
plt.imshow(slc, cmap='gray'): Plots the selected slice with a grayscale colormap. -
plt.title('Original'): Sets the title of the plot to ‘Original’. -
plt.show(): Displays the plot.
-
-
Adjusting Orientation:
-
slc = slc.transpose(1, 0): Transposes the dimensions of the slice, effectively swapping the axes from inferior-superior (I-S) to posterior-anterior (P-A).- This operation changes the orientation of the slice by exchanging the axes, which can be useful for adjusting the display orientation.
-
slc = slc[::-1, :]:- By reversing the rows, the orientation of the slice is corrected, ensuring proper anatomical orientation. effectively reverses the order of rows in the 2D array slc, flipping the slice vertically. This operation ensures that the slice is properly oriented along the inferior-superior (I-S) axis,
-
-
Plotting Final Slice:
-
plt.imshow(slc, cmap='gray'): Plots the adjusted slice with a grayscale colormap. -
plt.title('Final'): Sets the title of the plot to ‘Final’. -
plt.grid(True): Adds grid lines to the plot for better visualization. -
plt.show(): Displays the final plot.
-
Explain this code - (6)
The code imports the necessary libraries: nibabel (as nib) and matplotlib.pyplot (as plt).
It then loads a structural NIFTI file named ‘highres.nii.gz’ using the ‘nib.load()’ function and stores it in the variable ‘s’.
The ‘s.get_fdata()’ function retrieves the image data from the NIFTI file and stores it in the variable ‘data’.
in floating-point format
Additionally, the ‘s.get_qform()’ function retrieves the affine transformation matrix (qform matrix) associated with the NIFTI file and stores it in the variable ‘qform’.
This matrix contains information about the spatial orientation and voxel dimensions.
Finally, the ‘s.orthoview()’ function is called, which automatically produces three views of the data, labeling them as anterior, posterior, superior, and inferior.
Output of this code:
In this output - (2)
labels left on left and right is on right
However, in FSL this is flipped other way as in radiological convention so be careful looking at fMRI should be labelled
In the notebook this will just print out three static views of the data. That’s fine but we can do better. If you run it in Spyder it will bring up a complete volume browser that you - (2)
you can click around in spyder by simply uploading same code you did in Colab and changing
s = nib.load(‘highres.nii.gz’) which works in Colab to
s = nib.load(‘C:\Users\gs1211 (whatever usename you have)\pin-material\s7_fmri\highres.nii.gz’)
How to tell spyder to install nibabel? - (2)
In the Spyder Console (Bottom Right) type:
pip install nibabel
How to tell spyder we want interactive graphics? - (5)
Go into the Preferences window like this
Tools->Preferences
From the iPython Console settings:
Select Graphics -> Graphics Backend -> Qt5
And hit ‘Apply’
Explain this code -(5)
producing mask
This code snippet performs several operations on a structural NIFTI file to create a mask and save it. Let’s break down each step:
-
Loading the NIFTI File:
- The code starts by loading a structural NIFTI file named ‘highres.nii.gz’ using the
nib.load()function from the nibabel library. This file contains MRI data.
- The code starts by loading a structural NIFTI file named ‘highres.nii.gz’ using the
-
Extracting Structural Data:
- Once the file is loaded, the structural data is extracted using the
get_fdata()method, and it’s stored in a variable nameddata. - The
print(data.shape)statement displays the shape of the extracted data. This provides information about the dimensions of the MRI data. - (176, 256, 256)
- Once the file is loaded, the structural data is extracted using the
-
Modifying Data to Create Mask:
- Next, a specific region within the data is modified to create a mask. The code sets voxels in a box-shaped region (with indices ranging from 100 to 169 along each axis) to the value 255. This operation effectively creates a mask where the selected region is marked with 255, indicating the presence of the mask. - #setting all one partof the data to be the same value of ‘255’ - inserting bick of 255 values inside someone’s head
- This process allows for the creation of a mask that can be used to isolate specific areas of interest within the MRI data.
-
Creating a New NIFTI Image in memory:
- After modifying the data to create the mask, a new NIFTI image is created in memory using the modified data. This is achieved using the
Nifti1Imageconstructor from nibabel. - The constructor requires three arguments: the modified data (mask), the affine transformation (
s.affine), and the header information (s.header) obtained from the original NIFTI file.
- After modifying the data to create the mask, a new NIFTI image is created in memory using the modified data. This is achieved using the
-
Writing/Saving to the Overlay:
- Finally, the newly created NIFTI image (mask) is saved as ‘my_overlay.nii.gz’ using the
nib.save()function. This function takes two arguments: the new image object (new_image) and the desired filename (‘my_overlay.nii.gz’). - #takes 2 arguements, dataset you made and name it
- Finally, the newly created NIFTI image (mask) is saved as ‘my_overlay.nii.gz’ using the
What mask does this code produce? - (2)
The code defines a box-shaped region within the MRI data, with boundaries set along the left-right (L-R), posterior-anterior (P-A), and inferior-superior (I-S) axes, corresponding to the X, Y, and Z dimensions, respectively.
Within this defined region, the voxel intensities are set to 255, effectively creating a binary mask where this specific region is highlighted, while the rest of the voxels remain unchanged.
What is output of this code? (spyder)
change to be smaller e.g., 100:110 to all
Explain this code that loads the fMRI data, extracts header information, and prints some details about the data - (6)
- The code begins by importing necessary libraries: nibabel for working with NIFTI files, matplotlib.pyplot for plotting, and numpy for numerical operations.
- It loads fMRI data from a NIFTI file named ‘func_data.nii.gz’ using the nibabel.load() function.
- The header and data are then extracted from the loaded file using the .header and .get_fdata() methods, respectively.
- The header contains essential information about the data, such as its dimensions and pixel dimensions, which are printed using the hdr[‘dim’] and hdr[‘pixdim’] statements.
- The size and type of the data array are printed using the data.shape and type(data) statements, respectively.
- This provides an overview of the fMRI data, including its dimensions and voxel size, facilitating further analysis or visualization.
Explain the output from this code of loading and extracting info of fMRI data - (6)
The first line [ 4 80 80 64 160 0 0 0] represents the dimensions of the data. Each number corresponds to a specific dimension:
The first number (4) indicates that the data has four dimensions - we have four-dimensional data. This makes sense as we now also have a time dimension.
The subsequent numbers (80, 80, 64, 160) represent the size of each dimension: 80 voxels along the first dimension, 80 voxels along the second dimension, 64 voxels along the third dimension, and 160 time points along the fourth dimension.
Looking at the next four numbers, we find that each of our images is (80, 80, 64) and that we have 160 of them (so 160 time-points).
The pixel dimensions tell us that the voxel size in this case is 3x3x3; i.e. we have a 3x3mm acquisition with 3mm slices. The next number in the pixdim array is the TR: in this case that is 2s. - blocks of brain collected every 2s and dimensins of block 3,3,3mm
The third line (80, 80, 64, 160) - this shape specification indicates that the data array comprises 80 voxels in the x-direction, 80 voxels in the y-direction, 64 voxels in the z-direction, and 160 time points, forming a four-dimensional array.
We can add f.orthoview()
at end to make it interactive:
Extending this code to produce graphs of voxel from two different positions - explain the code - (8) with output
This code plots the time-series for two voxel positions using data obtained from fMRI.
It uses the ‘ggplot’ style for visualization and plots the signals from two different voxels in blue and red, respectively.
It also adds labels for the x-axis and y-axis, as well as a legend to distinguish between the two voxel positions.
Because we now have data available as a numpy array, we can plot it.
This time we choose two (very non-accidentally chosen) voxels and plot the timeseries for each of them:
The first thing to note is that this is the raw image-space data from the scanner; it has not been pre-processed in any way.
The second thing is that it looks like we have almost periodic responses in each of these voxels. In Voxel 1 (plotted in blue) we have 10 cycles through the experiment (32 seconds per cycle).
In Voxel 2 (plotted in red) we have 16 cycles through the experiment (20 seconds per cycle). It is almost as though the person was doing two different tasks or having different parts of their brain stimulated at different frequencies.
Explain this code that plots three different voxels - (5)
Imports necessary libraries: nibabel for working with NIFTI files, matplotlib.pyplot for plotting, and numpy for numerical operations.
Loads the fMRI data from the file named ‘filtered_func_data.nii.gz’.
Extracts header information (hdr), voxel data (data), and the qform matrix (qform) from the loaded NIFTI file.
Prints some header information, including the dimensions (hdr[‘dim’]), pixel dimensions (hdr[‘pixdim’]), and shape of the data array (data.shape).
Plots the time-series data for three specific voxels (p1, p2, and p3) on the same graph p1: represents voxel data at position (29, 29, 40), p2 represents voxel data at position (50, 29, 40)., p3 represents voxel data at position (46, 9, 30).
What do the coordinates represent in the context of the code snippet p1=data[29, 29, 40, :], p2=data[50, 29, 40, :], and p3=data[46, 9, 30]? - (4)
In the context of fMRI data, the coordinates represent the spatial location of specific voxels within the brain volume.
Each set of coordinates specifies the position of a voxel along the x, y, and z axes, respectively.
For example, in p1=data[29, 29, 40, :], the voxel is located at coordinates (29, 29, 40), indicating its position along the x-axis (29 units), y-axis (29 units), and z-axis (40 units).
Similarly, p2=data[50, 29, 40, :] and p3=data[46, 9, 30] represent voxels located at different spatial coordinates within the fMRI volume.
Output of this code
Those are the two voxels we looked at before plus another one that doesn’t seem to be active.
We can then produce fourier transform of each voxel using this code
Explain it - (6)
-
fp1=abs(np.fft.fft(p1)),fp2=abs(np.fft.fft(p2)), andfp3=abs(np.fft.fft(p3)): These lines apply the Fourier Transform to each voxel time series (p1,p2, andp3) to compute the amplitude of each frequency component. -
plt.figure(figsize=(15,5)): Creates a new figure for plotting with a specific size. -
plt.bar(np.arange(29)+.8,fp1[1:30],width=0.2),plt.bar(np.arange(29)+1,fp2[1:30],width=0.2),plt.bar(np.arange(29)+1.2,fp3[1:30],width=0.2): These lines generate bar charts for each voxel’s Fourier transform. They plot the amplitudes of the Fourier transform components (from frequencies 1 to 29) along the x-axis, with slight adjustments to the bar positions to avoid overlap. -
plt.xlabel('Frequency (cycles/expt)'),plt.ylabel('Signal amp (au)'): Sets labels for the x-axis and y-axis of the plot. -
plt.legend(['Voxel 1', 'Voxel 2','Voxel 3']): Adds a legend to the plot indicating which voxel each set of bars represents. -
plt.show(): Displays the plot.
What does output show of fourier transform of each voxel? - (3)
voxel 1 (red) clearly responding at 10 cycles per second - has 1 input
voxel 3 (lilac) responding at 10 and 16 cycles per second - has 2 inputs
voxe 2 (blue) that is weak has some power at every frequency - call white noise
explain in more detail what line of code does - (5)
plt.bar(np.arange(29)+1.2,fp3[1:30],width=0.2)
np.arange(29): Generates an array of integers from 0 to 28, representing the indices of the frequencies.
+1.2: Adds a small offset to the x-axis values, ensuring that the bars for each frequency are evenly spaced.
fp3[1:30]: Extracts the Fourier transform magnitudes for frequencies 1 to 29 (indexing is zero-based in Python).
width=0.2: Sets the width of the bars to 0.2 units.
Together, this line positions and plots the bars representing the Fourier transform magnitudes of the third voxel’s time-series data, ensuring proper spacing and visualization of the frequency spectrum.
Explain this code- (7)
Fourier Transform (FT) Calculation: The code begins by computing the Fourier transform of the entire fMRI data array (data) using NumPy’s Fast Fourier Transform (FFT) function (np.fft.fft()). The FFT is applied along the first dimension, which represents time. This step decomposes the time series data into its frequency components, providing insights into how different frequencies contribute to the signal.
Magnitude Extraction: After computing the FFT, the code uses the abs() function to extract the magnitude of the resulting complex numbers. This is necessary because the FFT output includes both real and imaginary components. By taking the absolute value, we obtain the magnitude of each frequency component, which represents the strength or amplitude of the signal at that frequency.
Frequency Response Extraction: Next, the code extracts the frequency responses at 10 and 16 times per experiment from the magnitude data (fData). These frequencies are of interest because they may correspond to specific experimental conditions or stimuli. The extracted responses are stored in arrays response10 and response16, respectively, creating 3D maps of response magnitudes across all voxels in the fMRI data.
Slice Selection: To visualize the frequency responses, the code selects specific slices (s10 and s16) from the response maps. These slices represent responses at particular voxels within the brain. However, since the orientation of the data may not be optimal for visualization, the code applies a transpose operation and reverses the order of elements along the second axis to ensure correct orientation ([:, :, ::-1].transpose()).
Plotting: The selected response slices (s10 and s16) are plotted side by side using Matplotlib’s imshow() function. Each subplot displays the response map at either 10 or 16 cycles per second. The ‘jet’ color map is utilized to visualize the intensity of responses, with warmer colors indicating higher response magnitudes. Additionally, titles are added to each subplot to denote the corresponding frequency.
Save Output: Finally, the code saves the generated response maps as NIFTI files (10cycles.nii.gz and 16cycles.nii.gz). These files can be further analyzed or visualized using neuroimaging software.
List Files: As a final step, the code executes a command (!ls -lat) to list the files in the current directory, providing an overview of the saved output files.
What does plt.subplot(1,2,1) mean? - (2)
The code utilizes Matplotlib’s subplot() function to organize the visualization of the frequency response maps.
By specifying (1,2,1) as the argument for the first subplot, it instructs Matplotlib to create a grid of subplots with one row and two columns and select the first subplot for the current plot.
What does response10=fData[:,:,:,10] do in code?
In the given code snippet, response10[29, :, ::-1] reverses the order of elements along the last axis of response10, ensuring proper orientation of the data for visualization
What is output
I have loaded in anantomical nifti file using nibabel like this:
What does the ‘dim’ key in the header represent?
The 3D or 4D dimensions of the image in voxels (and TRs if appropriate)
5:
I have a nifti file and I want to plot two different voxels of data from it. However although the data loads, I only see one line. What is wrong with this code and how can I fix it?
You are plotting p1 twice. Change the second ‘plt.plot’ statement to use p2 not p1
What is missing in this code?
Quotes are missing around the string.
What is the (main) mistake in this Python script intended to check if a number is divisible by
3?
The second print statement is always executed regardless of the output of the ‘if’ statement
What is wrong with the indentation in the following code? Explain your answer.
The line after the if statement should be indented
Identify and describe the error in this code snippet:
data and DATA are different variables because one is in upper case and the other is in lower
case.
Identify the issue with the input handling in the following code. How might you fix it? - (2)
The user might input a string for age and then the programme would crash.
You could use
try / except statement to loop until they enter a number.
What is the matter with this code?
There should be a : after the def doubleNumber(x)
I am trying to print the last element in this list. What is going wrong? How can I fix it?
len will give you a result of 5. You should use listLen-1 on the last line because lists are
zero-indexed.
I am printing some elements in a list in reverse order using range’s [start,stop,step] format.
Why isn’t it working? If I fix the bug, what numbers will it print? - (2)
The colon (:) is missing at the end of the second line.
If you fix it it will print 17,13,11,7,5,3
Why would using the .get member function make this code safer?
Because if someone enters a key that is not in the dict then at the moment it will crash on
line 3. .get will return ‘None’ if the key does not exist.
Here are two lists - (2)
How can I join them to make a new list called list3 which is:
[2,4,6,8,10,20,30,40]
(Two possible good answers) 1: Use + to join them: i.e. print (list1+list2) 2:
Use the .extend
member function: i.e. list1.extend(list2) print(list1)
f-strings allow me to include variable values inside print statements. What would be the output
of the following code:
2.32
1.202
001
This code uses the range(start, stop, step) format to print the results of dividing 10 by lots of
different even numbers. It will throw an error right at the end - why and how can I fix it? - (2)
The last number is zero so you get a ‘Divide by Zero’ error.
You could change the range to stop before zero. Or check to make sure ‘a’ is not zero with an
‘if’ statement.
Here is a function to raise one number to the power of another. What is going wrong when I
call it inside the print statement?
The function does not return a value so the part inside the bracket will return ‘None’ for every
call.
I’m trying to write a while loop but it’s not running at all. Can you see why?
It should be a==1 at the while statement (to test if a equals 1).
I have a psychopy reaction time task with three components. They are:
25s (Average ISI is 1.5s, the rest is 1s, total=2.5s, 10 repeats)
I accidentally set the ISI to this:
When I look at the reaction times they are much shorter - some of them are almost zero. How
can this be?
The ISI is always the same (1) so people can anticipate the cue
I am using CircuitPython to flash an onboard LED red, then green with each colour coming
on for 500ms. The code below does not seem to work - the light just stays on white. Assuming
all the libraries are present and loaded correctly, what’s the problem?
The led values should be (255,0,0) for RED and (0,255,0) for GREEN
This code is supposed to flicker the LED randomly at 50Hz. It just fails to run at all. The
library random is present and random.randint(x,y) returns a random integer between x and
y.
I can’t see the error on the terminal - can you suggest what the issue might be?
You are not importing the neopixel library
As an exercise I am trying to use list comprehension to generate a new list and then do exactly
the same thing with a for loop. However, the two lists are not the same. Here is the code.
Why do they not match? - (2)
You should append x to myList2 in the for loop.
So myList2.append(x) not myList2=x
What will this function do? - (4)
The quick answer is ‘It checks to see if the number is prime’
Stepping through the code: First it checks to see if it’s <2 (1 is not prime) or 2 (2 is prime).
Then it goes through all the numbers up to n-1 and sees if any of them divide into n with no
remainder.
If they >do< then the function returns ‘False’. Otherwise you get to the end and
there are no factors so it returns ‘True’.
I am using matplotlib to make nice plots. Here is one: - (4)
Briefly describe what it looks like
The variable x is created using np.arange(-10, 11, 1), which generates an array of integers from -10 to 10, inclusive.
The y-values are calculated as x * 2. This means each y-value is twice the corresponding x-value, forming a linear relationship.
The plot displays green circular markers at coordinates (x, 2x) for each x in the range from -10 to 10.
The x-axis ranges from -10 to 10, and the y-axis ranges from -20 to 20 to accommodate the y-values.
Here are two distributions plotted as histograms. Which one (data1 or data2) will have the
smallest standard deviation?
data1 -
In the code below, the data file rawdata_mcf.nii.gz exists and is loaded correctly. The file
contains a 4D array and has 120 TRs of data.
When the data are plotted they look very noisy. There are lots of drifts, mean offsets and
high frequency noise components. The file has already been motion-corrected.
What simple
thing might you do to make the data nicer to look at initially? Just describe the operation,
you don’t have to know the exact command.
Filter the data using a band-pass filter to remove very high and low frequencies
In nilearn I can set up a ‘First Level Model’ and fit the GLM in one go like this:
a) What do these columns represent?
b) How might I reduce the number of additional columns?
a: Models of the low-frequency drifts
b: Change the ‘high_pass’ parameter to something lower like .001
I am looking at some MEG data from another lab. My results seem to be pretty noisy. I use
an MNE function called compute_psd to compute the ‘power spectral density’: the power at
each frequency like this:
When I look at the frequency power spectrum of the data it has big spikes at 60Hz and
120Hz.
a) What might these spikes be due to
b) Suggest a simple way to remove them. Describe the operation, you do not need to know
the exact syntax.
a) “Line noise” - electrical interference at the mains frequency
b) A notch filter : Specifically notch filter at 60 and 120Hz
What will be the output of the following code and why? - (2)
The output will be: x is greater than 5
Because 10 is greater than 5, the condition x > 5 evaluates to True.
Explain why the following code does not print “Hello, World!”. - (2)
The print statement inside the function needs to be indented.
The correct code is:
Identify and describe the error in this code snippet: - (3)
The index 3 is out of range because the list numbers has only three elements,
indexed from 0 to 2.
Attempting to access numbers[3] will cause an IndexError.
How can you modify this code to ensure it handles potential exceptions when converting input to an integer?
You can use a try/except block to handle exceptions:
What is the problem with this loop, and how can you fix it?
The print statement and the increment should be indented within the while loop.
Identify the issue with the function and suggest a fix. - (2)
The function call add(5) is missing a second argument.
The correct call should be add(5, b) where b is defined. For example:
What will be the output of this code and why? - (2)
0
1
2
The loop stops when i equals 3 due to the break statement.
Explain the error in the following code and how to correct it.
The = operator is used for assignment, not comparison.
The correct operator is ==. The correct code is:
What is the error in this dictionary operation and how can it be fixed? - (2)
The key ‘gender’ does not exist in the dictionary, which will cause a KeyError.
You can use the .get() method to provide a default value:
What will be printed by the following code? Explain your answer - (2)
Both x and y will be [1, 2, 3, 4] because y is a reference to the same list as x.
Changes to y affect x as well.
Describe what this code does and provide the output. - (2)
This code creates a new list squared containing the squares of the numbers in the nums list.
The output will be:
What is wrong with the following code that is supposed to blink a NeoPixel LED red for 1 second and off for 1 second? - (5)
The code itself is correct and should theoretically blink the NeoPixel LED red for 1 second and then turn it off for 1 second in an infinite loop. However, there might be an actual error related to hardware or connection issues. Some potential reasons for the code not working as expected could be:
Incorrect Wiring: Ensure that the NeoPixel LED is connected to the correct pin on the microcontroller board.
Power Issues: Ensure that the NeoPixel LED is receiving sufficient power to function properly.
Defective Hardware: The NeoPixel LED or the microcontroller board might be defective.
Library Compatibility: Check if the neopixel library is compatible with the specific microcontroller board being used.
Explain what this code snippet does:
This code initializes 8 NeoPixel LEDs and sequentially lights each one green for 0.5 seconds before turning it off
Explain what the following NiBabel code does:
This code loads a NIfTI file (example.nii.gz), extracts the data array, and calculates the mean across the last axis (usually time) of the 4D fMRI data, resulting in a 3D mean image.
What is the purpose of the high_pass filter in this Nilearn FirstLevelModel setup?
The high_pass filter is used to remove low-frequency drifts from the fMRI signal, ensuring that only high-frequency signals (above 0.01 Hz) are analyzed.
Describe what the following MNE code does:
This code loads an MEG/EEG raw data file, applies a band-pass filter between 1 Hz and 40 Hz to remove low-frequency drifts and high-frequency noise, and plots the power spectral density (PSD) of the filtered data.
