Session 2 - Part 1 Flashcards
What is the term used to describe controlling text output and making it look nice in Python?
String formatting is the process of controlling text output and making it visually appealing in Python.
What is one way to print combinations of text and data in Python before the introduction of f-strings? - (3)
Joining them together with commas,
for example:
numberOfSubjects = 1022
print(“There were “, numberOfSubjects, “ participants”).
What are some drawbacks of using commas to combine text and data for output in Python? - (2)
Commas can be annoying and imprecise especially when trying to format output neatly
E.g., Unable to limit number of decimal places or centre things on screen
There were 1022 participants
What would be output of this code?
2.0 / 3.0 is roughly: 0.6666666666666666
Example image of:
Drawback of using commas to combine text and data for output in Python - unable to limit number of deciaml places example
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.
What is the output of this code?
My variable contains the value 100
How can you include multiple variables in an f-string in Python?
Multiple variables can be included in an f-string by separating them with commas inside the curly braces {}.
Example of adding multiple variables in f-string in Python
What will be the output of this code?
My vars are Test, 15.0, 10
The way in which the variables are output in f-string depends on the
data type
Example
The way in which the variables are output in f-string depends on the data type
the float in this case is shown with a .0 on the end whilst the int is not.
Explain this code - (4):
three variables a, b, and c are assigned values.
a is assigned 10 (integer)
b is assigned 15.0 (float)
c is assigned ‘True’ (boolean value)
An f-string named mystr is then created, which includes these variables within curly braces {} inside the string.
When mystr is printed, it will display the formatted string “My vars are Test, 15.0, 10”, with the variables c, b, and a inserted into the string in the order specified
What does the term “formatting with f-strings” refer to in Python? - (2)
“Formatting with f-strings” in Python refers to using f-strings to manipulate the appearance of output, such as justifying text or formatting data, by adding specific formatting options after the variable name.
Formatting options always have a colon at the end of the variable name and then some numbers or characters.
What are two ways in which we want to format strings in f-string? - (2)
- Justifying text (for example, by making sure it takes up a certain amount of space for each variable). This is useful when we want to print tables of data
- Format the data itself - for example limiting the number of decimal place in a float or adding zeros to the start of an integer
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: What does the following f-string do?
myvar = ‘Test’
print(f’==={myvar}===’)
This f-string prints the value of the variable myvar surrounded by equals signs, resulting in the output ===Test===.
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 left-alignment of string in f-string?
<: left aligned (the default so does not usually need to be specified)
What is right-alignment of string in f-string?
> : right aligned
What is centred-alignment of string in f-string?
^: centred
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 this code? - (2)
534, the original content was 3 characters long, and the f-string expanded the width to 7 characters by adding 2 spaces on each side to center the content.
=== 534 ===
Print your own name, centered in space surrounded by stars (**) like this:
** Alex **
Using f-strings
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 default alignment behavior of a numbers (integers, floats) in f-strings?
By default, strings are right-centered in the space provided within an f-string.
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.4f}==’)
where myval = 10.219? - (2)
The output is ==10.2190==. This displays the floating-point number 10.219 with a total width of 7 characters, including the number itself with four digits after the decimal point.
Since the specified width is sufficient to accommodate the entire number, no leading or trailing spaces are added.
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 is the output of the code print(f’==={myvar:10}===’) where myvar = 5? - (2)
The output is
=== 5===
This indicates that the output is right-aligned, with 9 spaces added before the number 5 to achieve a total width of 10 characters.
We can also use … in f-strings which is useful for dealing with large or small nubmers (e.g., femot-Tesla in MEG)
scientific notation
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 output of the code?
P001 | 100 | 100.210 |
Fix this code so it outputs like this:
P001 | 100 | 100.210 |
| P002 | 150 | 121.542 |
| P003 | 88 | 99.122 |
| P004 | 120 | 145.330 |
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 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
What is the output of this code if user input is Gita and number input is 2
Enter a name:Gita
Gita
Enter a number: 2
<class ‘int’>
This is your original number: 2
This is your number doubled: 4
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
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}.
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’>.
Example of keyerror exception
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
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}
{}
What is an example of a real-world use of a dictionary?
Storing participant IDs linked to their ages, where each participant ID serves as a key and the corresponding age serves as the value.
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
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)
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
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]
Methods sections in human neuroscience papers usually list the mean (average) age of the participants. How might we compute this? We can start with a dictionary of ages as above and compute the mean of the participants’ ages by adding up all the ages and dividing by how many there are
What is output of this code?
Mean age of participants is: 37.0
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
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.
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,
2.4.6 Quick Exercise
You are making a database for your experiment:In the code below you will:
1: Create an empty dictionary which will be used to map IDs to ages.
2: Write a loop which goes around three times and, each time, lets the user input an ID or name and then an age. Each time, add a new entry to the dictionary.
3: Print out the dictionary using the normal print command. Then try printing the dictionary, one item at a time, after sorting the names alphabetically. Try and make this second output look as neat as possible using the formatting rules we discussed in the previous session.
Useful keywords that are used here: input
range
print(f””)
sort
for …. in ….
sorted(…)
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.
