Session 4 - Part 2 Flashcards
1
Q
Although we are processed small amounts of data like single numbers or long lists, neuroimagning data however,
A
contains millions of numbers and processing these one ar a time with loops is not going to work
2
Q
For larger scale data analysis (usually with neuroimagning data) we can use pre-existing modules and core tool for this in Python is
A
numpy
3
Q
Numpy works with
A
large blocks of numbers called ‘matrices’ (or sometimes ‘arrays’)
4
Q
Matrices are often rectangular blocks that are
A
stored as rows x columns
5
Q
Matrices are often rectangular blocks that are stored as rows x columns.
For instance:
A
3 rows by 2 columns so it would have shape (3, 2).
6
Q
The order of the dimensions of matrices is always
A
(rows, columns).
7
Q
For most of the time we will be working with 2D matrices, however numpy will cope with any number of dimension from
A
(from 1D up to any number of dimensions).
8
Q
Matrices are usually two-dimensional whereas arrays can be
A
have any number of dimensions
9
Q
when performing addition, subtraction, multiplication, or division on matrices, they must be of
A
he same size, meaning they must have the same number of rows and columns.
10
Q
Example of addition of matrices
A
11
Q
Example of subtraction of matrices:
A
12
Q
Example of multiplication and division of matrices - element by element mulplication/division|
A
13
Q
numpy and scipy are two modules that support for much of the
A
scientific work that you will want to do in Python
14
Q
numpy provides “low-level” routines for manipulating matrices like
A
linear algebra routines (e.g. inverting a matrix), Fourier transforms and random number capabilities (using a range of distributions).
15
Q
scipy provides “higher-level” routines for science and engineering and uses numpy as base and then adds
A
additional algorithms for things like image and signal processing.
16
Q
matplotlib is a
A
plotting library that lets you produce a range of different graphs
17
Q
Numpy uses the numpy.array class to store
A
arrays of numbers
18
Q
Numpy arrays can be any
A
number of dimensions and any size
19
Q
Python is a 0-indexed language. This means that if we have a2x2 array
A
the two rows are referred to using indices 0 and 1 and the two columns are referred to using indices 0 and 1.
20
Q
When indexing into numpy arrays, we use
A
square brackets (similar to lists).
21
Q
We can also use a range separated by a colon (:) in array which is exclusive of last number (similar to range function) e.g., - (2)
A
data[0:100, 0:100] This gives us a 100x100 subarray of the data array
data[50:, :] This gives us the 51st row onwards and all of the columns –> In Python, indexing starts from 0, so the 51st row corresponds to index 50. T
22
Q
A
23
Q
Explain the code please - (5)
A
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.
24
Q
What is the output of the code?
A
Here is an array of zeros
[[0. 0. 0.]
[0. 0. 0.]]
25
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.
26
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.
27
28
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.
29
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.
30
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.
31
What does single_num = z[0,1] do if we print it out? - (2)
z = np.zeros((2,3)) producing 2x3 matrix of zeros
Extracts a single number from the first row and first column of the matrix
The item at z[0,1] is 0.0
32
33
What does a_row = z[0,:] do if we print it out? - (3)
z = np.zeros((2,3)) producing 2x3 matrix of zeros
In the context of array indexing in NumPy, the comma separates the row index from the column index.
In this expression, z[0, :], 0 indicates the row index (specifically the first row), and : indicates that all columns in that row are selected.
Output:
[0. 0. 0.]
34
So with matrices we can set
certain elements to be certain values as well as extract single and multiple numbers
35
36
What does rArray=np.random.rand(200,200) do?
This line initializes a NumPy array named rArray with dimensions 200x200 filled with random numbers generated using np.random.rand().
37
What does print(f'Array size={rArray.size}') display?
if rArray=np.random.rand(200,200)
This line prints the total number of elements in the rArray array which is 4000
38
What does rint(f'Array shape={rArray.shape}')display?
if rArray=np.random.rand(200,200) - (2)
This line prints the shape of the rArray array, which represents its dimensions as a tuple (rows, columns)
output: Array shape=(200, 200)
39
What does smallerArray=rArray[0:100,0:100] do
if rArray = np.random.rand(200,200)
This line creates a subset of the rArray array, selecting rows from index 0 to 99 and columns from index 0 to 99, effectively creating a smaller 100x100 array from the original 200x200 array.
40
: How can the size parameter in np.zeros be represented, according to the comment # The size thing here is a tuple - it can also be a list?
The size parameter in np.zeros can be represented as either a tuple or a list, allowing flexibility in specifying the dimensions of the array to be created.
41
Explain the code - (4)
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,:])
This code snippet begins by importing the NumPy library and aliasing it as np.
It then initializes a 2x3 NumPy array named z filled with zeros.
The line z[1, 2] = 9 modifies the bottom-right element of the array to 9.
Finally, it prints the second row of the array using print(z[1, :]), where z[1, :] selects the entire second row of the array.
42
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,:])
43
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.
44
We can also produce an array filled with ones instead of zeros using
np.ones((3,4)
45
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.
46
What is the output of this code?
47
If we want to type in some data we can produce an array by hand using np.array function e.g., - (2)
a = np.array([[1, 2, 3,8], [4, 5, 6,9]])
#Create a 2x4 array of numbers - we do this by converting a list of lists to an array.
48
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".
49
What is the output of this code?
50
If you entered all integers in your array then
it produces an int array
51
There are 3 ways to produce a float array - (3)
1. Force a float array by making at least one number floating point with a decimal point
2. Force a float array by specifying it to numpy at creation time using dtype
3. Force a float array by explicitly casting an int array
52
Ways to produce float array
1. Force a float array by making at least one number floating point with a decimal point
a = np.array([[1.0, 2, 3], [4, 5, 6]])
print(a)
Output:
[[1. 2. 3.]
[4. 5. 6.]]
53
Ways to produce float array
2. # Force a float array by specifying it to numpy at creation time
a = np.array([[1, 2, 3], [4, 5, 6]], dtype=float) # <--- that dtype thing tells numpy to make it floats
print(a)
output:
[[1. 2. 3.]
[4. 5. 6.]]
54
What does single_num = z[0,1] do if we print it out? - (2)
z = np.zeros((2,3)) producing 2x3 matrix of zeros
Extracts a single number from the first row and first column of the matrix
The item at z[0,1] is 0.0
55
Ways to produce float array
2. Force a float array by explicitly casting an int array
a = np.array([[1, 2, 3], [4, 5, 6]]) # Initially it's an int array...
a = a.astype(float) # ... but now we've 'floated' it!
print(a)
output:
[[1. 2. 3.]
[4. 5. 6.]]
56
explain code - (5)
a = np.array([[1.0, 2, 3], [4, 5, 6]])
print(a)
This code creates a NumPy array named a containing two rows and three columns.
It ensures the array contains floating-point numbers by including at least one number with a decimal point (1.0).
By including a floating-point number (1.0) in the array, it forces NumPy to interpret all numbers in the array as floating-point numbers.
Therefore, even though some numbers are entered as integers (2, 3, 4, 5, 6), they will be converted to floats when the array is created.
Finally, it prints the array a.
57
explain this code:
a = np.array([[1, 2, 3], [4, 5, 6]], dtype=float) # <--- that dtype thing tells numpy to make it floats
print(a)
This code initializes a 2x3 NumPy array with the values [[1, 2, 3], [4, 5, 6]] and forces every integer value to be a float by specifying dtype=float and prints the resulting array.
58
Break down what a = np.array ([[1.0,2,3],[4,5,6]]) mean - (3)
So, [[1.0, 2, 3], [4, 5, 6]] creates a 2x3 array - 3 elements in the list so 3 columns and 2 lists meaning 2 rows
The first inner list [1.0, 2, 3] represents the first row of the array. It contains three elements: 1.0, 2, and 3.
The second inner list [4, 5, 6] represents the second row of the array. It also contains three elements: 4, 5, and 6.
59
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.
60
You can also replace dtype as float with
int e.g., a = np.array([[1, 2, 3.3], [4, 5, 6]], dtype= int)
61
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.
62
What is output of the code going to be - going to be same even if its 3.6 instead of 3.6
63
when specifying the data type as int using dtype=int, any float values are truncated to integers. So, for example, if a value is 3.6, it will be
converted to 3.
64
In numpy module, you can also use other data types such as
as np.complex for complex numbers, np.bool for arrays of bools and a range of more specialist types if you need to.
65
You can also produce a list then
convert to array using np.array
66
Example of converting list to numpy array
67
What will be output of the code?
68
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`,
69
For many reasons, we often want to make ... in arrays
ranges of numbers in arrays
70
For many reasons, we often want to make ranges of numbers in arrays.
There are quite a few ways to do this but the two it is important to remember and know about are - (2)
np.arange and np.linspace
71
What are the main differences between np.arange and the built-in range function? - (2)
The main differences are:
np.arange returns a NumPy array object of dtype int or float depending on what data type is specificed, while range returns a sequence of integers
np.arange can handle floating-point numbers, whereas range only works with integers.
72
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,
73
What would be the output of this code?
74
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()`.
75
Normally leaving this line out of plt.show() will still show plot in colab but might be
a warning
76
How to produce x range from -5 to 5 inclusive with steps of 1?
x = np.arrange(-5,6,1)
77
What is the purpose of np.linspace in Python?
np.linspace is used to generate a specified number of evenly spaced numbers between a start and stop value.
78
What are the arguements to the function called np.linspace?
(start, stop, count)
79
What does the following code snippet do? - (4)
import numpy as np
#Get 5 equally spaced numbers between 0.0 and 1.0 inclusive
a = np.linspace(0.0, 1.0, 5)
print(a)
This code uses `np.linspace` to generate an array `a` containing 5 equally spaced numbers between 0.0 and 1.0 (inclusive).
The `np.linspace` function takes three arguments: the start value (0.0), the stop value (1.0), and the number of values to generate (5).
It returns an array with equally spaced numbers, including both the start and stop values.
The resulting array `a` is then printed.
80
Output of this code
import numpy as np
#Get 5 equally spaced numbers between 0.0 and 1.0 inclusive
a = np.linspace(0.0, 1.0, 5)
print(a)
[0. 0.25 0.5 0.75 1. ]
81
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:
82
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()`.
83
To make graphs smoother then change
the steps in np.array/counts in np/linspace
84
The np.linspace produces an array? - (2)
produces an array.
It generates evenly spaced numbers over a specified interval and returns them as an array.
85
Numpy can produce
random numbers
86
Functions for producing random numbers from numpy come from
np.random module
87
Output of 1D array vs 2D array:
88
The np.random.rand in np.random module for producing random numbers produces
evenly distributed numbers between 0 and 1.
89
The parameter we pass to the np.random.rand function is the - (5)
size of the array of random numbers that we require.
This parameter determines the shape of the output array in terms of rows and columns.
For example:
np.random.rand(5) will generate a 1D array with 5 elements.
np.random.rand(3, 4) will generate a 2D array with 3 rows and 4 columns.
90
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`
91
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()`.
92
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'.
93
Another function in numpy to produce random numbers in np.random module is
np.random.randn
94
The randn function in Numpypy produces... - (2)
The randn function in NumPy generates random numbers drawn from a normal distribution.
The 'n' at the end of the function name indicates that it follows a normal distribution.
95
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()`.
96
We can visualise these two sets of numbers side-by-side using the
subplots function of matplotlib
97
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().
98
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.
99
Arithmetic on numpy arrays works in the way you would probably expect. To perform arithmetic on two arrays, they normally need to be
the same size
100
How does scalar arithmetic work with numpy arrays?
Scalar arithmetic with numpy arrays involves operating on the entire array with a single number, known as a 'scalar'.
101
Explain this code - (4)
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)
Two arrays 'a' and 'b' are defined with the same dimensions, both being 2x2 arrays.
The arrays 'a' and 'b' are added together element-wise, resulting in array 'c'.
Array 'a' is multiplied by scalar 10, resulting in array 'd'. Since 'a' is a 2x2 array, 'd' will also be a 2x2 array where each element of 'a' is multiplied by 10.
The arrays 'a', 'b', 'c', and 'd' are printed to observe the results of the operations.
102
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)
103
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.
