3.3 - Boolean Values, Conditional Execution, Loops, Lists & List Processing, Logical & Bitwise Operations (PCEP-30)
example comments; the i variable takes the values 0, 1, 2, 3, and 4, and then it indexes the list, selecting the subsequent elements: the first, second, third, fourth and fifth;
each of these elements is added together by the += operator to the total variable, giving the final result at the end of the loop;
**key takeaways; end
end
"List comprehension" allows you to create new lists from existing ones; in a concise and elegant way. The syntax of a list comprehension looks as follows [expression for element in list if conditional]
for element in list: if conditional: expression
example 3; swapping values in lists using 'for loop' my_list = [10, 1, 8, 3, 5] length = len(my_list)
for i in range(length // 2): my_list[i], my_list[length - i - 1] = my_list[length-i-1], my_list[i] print(my_list) [5, 3, 8, 1, 10]
Similarly, if you omit the end in your slice, it is assumed that you want the slice to end at the element with the index; len(my_list)
len(my_list)
There is also a list method called reverse(), which you can use to reverse the list (flip for example)
lst = [5, 3, 1, 2, 4] print(lst) lst.reverse() print(lst) # outputs: [4, 2, 1, 3, 5]
You can use the sort() method to sort elements of a list (flip for example)
lst = [5, 3, 1, 2, 4] print(lst) lst.sort() print(lst) # outputs: [1, 2, 3, 4, 5]
You can test if some items exist in a list or not using the keywords "in" and "not in" (flip card)
my_list = ["A", "B", 1, 2] print("A" in my_list) # outputs: True print("C" not in my_list) # outputs: True print(2 not in my_list) # outputs: False
The len() function may be used to check the list's length (flip for example)
my_list = ["white", "purple", "blue", "yellow", "green"] print(len(my_list)) output: 5
Lists can be iterated through using the "for" loop (flip for example)
my_list = ["white", "purple", "blue", "yellow", "green"] for color in my_list: *print(color) (output: white. purple, blue, yellow, green **all on separate lines)
You can delete slices using the "del" instruction (flip card)
my_list = [1, 2, 3, 4, 5] del my_list[0:2] print(my_list) # outputs: [3, 4, 5] del my_list[:] print(my_list) # deletes the list content, outputs: []
The start and end parameters are optional when performing a slice: list[start:end] When you have a integer in 'end', that spot is not include in the slice, however if it's blank (in the end spot), it's include because you are going off of the length of the list (flip card)
my_list = [1, 2, 3, 4, 5] slice_one = my_list[2: ] slice_two = my_list[ :2] slice_three = my_list[-2: ] print(slice_one) # outputs: [3, 4, 5] print(slice_two) # outputs: [1, 2] print(slice_three) # outputs: [4, 5]
list elements can be deleted (flip for example)
my_list = [1, 2, 3, 4] del my_list[2] print(my_list) # outputs: [1, 2, 4] del my_list # deletes the whole list
The "list" is a type of data in Python used to store multiple objects. It is an ordered and mutable collection of comma-separated items between square brackets
my_list = [1, None, True, "I am a string", 256, 0]
if you want python to sort your list in 'ascending order', do the following (flip card)
my_list = [8, 10, 6, 2, 4] my_list.sort() print(my_list) output: [2, 4, 6, 8, 10]
how do you update indices within a list?
my_list [1] = $ would update element 2, with $
list sorting; how do you sort a variable in ascending order? use the variable my_list (my_list.sort())
my_list.sort() you would then print the results
example 2; swapping values in lists my_list = [10,1,8,3,5]
my_list[0], my_list[4] = my_list[4], my_list[0] my_list[1], my_list[3] = my_list[3], my_list[1] [5, 3, 8, 1, 10]
If you omit the start in your slice, it is assumed that you want to get a slice beginning at the element with index 0; what are 2 ways to represent this?
my_list[:end] my_list[0:end]
if end is omitted in slice; what are 2 ways you can type this out in python? (
my_list[start: ] my_list[start : len(my_list)]
lists can be ________ (nested)
nested; brackets inside of brackets
example; 'in' operator, lists my_list = [0, 3, 12, 8, 2] print(5 in my_list)
output False; 5 isn't in the list
example; 'not in' operator, lists my_list = [0, 3, 12, 8, 2] print(5 not in my_list)
output True; 5 isn't in the list
slices; If the start specifies an element lying further than the one described by the end (from the list's beginning point of view), the slice will be empty
output would be the following []
a typical method invocation looks like this: result = data.method(arg)
result = data.method(arg)
A typical function invocation looks as follows: result = function(arg)
result = function(arg)
You can use 'negative' indices to perform slices, too. For example: (flip card)
sample_list = ["A", "B", "C", "D", "E"] new_list = sample_list[2:-1] print(new_list) # outputs: ['C', 'D']
section continued
section continued
A "slice" is an element of Python syntax that allows you to make a brand new copy of a list, or parts of a list. It actually "copies the list's contents", not the list's name.
slice; copies the list's contents
If you want to copy a list or part of the list, you can do it by performing __________ (slicing)
slicing
***start of the 'key takeaways'
start
**the key takeaways, start
start
in order to update, how is the indices arranged in a list? (starts with zero)
starts with zero
Lists; and many other complex Python entities; are "stored" in different ways than ordinary; scalar; variables
stored in a different way
slicing example; colors = ['red', 'green', 'orange'] copy_whole_colors = colors[:] # copy the entire list copy_part_colors = colors[0:2] # copy part of the list
the 'end' doesn't include the integer
if a list contains 'other variables', the output will display what? (the value of those variables)
the value of those variables
we've launched the for loop to run through its body length // 2 times
this works well for lists with both even and odd lengths, because when the list contains an odd number of elements, the middle one remains untouched
***end of key obj
true
**key takeaways (beginning)
true
If you have a list L1, then the following assignment: L2 = L1 does not make a copy of the L1 list, but makes the variables L1 and L2 point to one and the same list in memory
true
It looks fine with five elements. Will it still be acceptable with a list containing 100 elements? No, it won't. Can you use the for loop to do the same thing automatically, irrespective of the list's length? Yes, you can.
true
Lists can be indexed and updated
true
The for loop has a very special variant that can process lists very effectively - let's take a look at that
true
Using negative values for both start and end is possible (just like in indexing).
true
You can use 'nested lists' in Python to create "matrices" (i.e., two-dimensional lists)
true
adding elements to a list; You can start a list's life by making it empty, this is done with an empty pair of square brackets, and then adding new elements to it as needed
true
end is omitted in slice; the significance with the 'len(my_list)' the last index is included because the length of the list is more than the number of indices since the indices start at 0
true
how do you swap the values of two variables? you need the 2 variables you would like to swap; and a 3rd variable that serves as an auxiliary storage
true
lists; slices my_list[start:end] 'start' is the "index" of the 'first element included' in the slice; end is the "index" of the first element not included in the slice.
true
nested lists; lst = [1, [2, 3], 4] looks like if there is a nested list, the bracketed portion inside the list is its own index; where the length is 3 of the entire list
true
note the way in which the len() function has been employed - it makes the code independent of any possible changes in the list's content
true
the for instruction specifies the variable used to browse the list; i here; followed by the in keyword and the name of the list being processed; my_list here
true
the i variable is assigned the values of all the subsequent list's elements, and the process occurs as many times as there are elements in the list
true
the name of a list is the name of a "memory location where the list is stored"
true
the name of an ordinary variable is the "name of its content"
true
this means that you use the i variable as a copy of the elements' values, and you don't need to use indices
true
we've assigned the length variable with the current list's length, this makes our code a bit clearer and shorter
true
review; for loops if you have a range(2) how many times will the loop execute? (twice)
twice
how would this look in python if you want to swap values of 2 variables? (flip card) the output using the print function would be 2,1
variable_1 = 1 variable_2 = 2 variable_1, variable_2 = variable_2, variable_1
checks if a given element; its left argument; is currently stored somewhere inside the list; the right argument; - the operator returns True in this case.
'in' operator
checks if a given element; its left argument; is absent in a list - the operator returns True in this case. (not in operator)
'not in' operator
what two methods can you use to update a list? (append, insert)
- append (adds to the end of the list) - insert (puts value in specific spot, and shifts everything to right)
Python offers two very powerful operators, able to look through the list in order to check whether a specific value is stored inside the list or not. what are they? (in, not in)
- in - not in
my_list = [10, 1, 8, 3, 5] total = 0 for i in range(len(my_list)): *total += my_list[i] print(total)
27
my_list = [10,1,8,3,5] total = 0 for i in my_list: *total+=i print(total)
27
One of the most general forms of the slice looks as follows: my_list[start:end] (flip card)
As you can see, it resembles indexing, but the colon inside makes a big difference
example; slice (flip for output; [1]) list_1 = [1] list_2 = list_1[:] list_1[0] = 2 print(list_2)
Its output is [1]. [:] is able to produce a brand new list.
The previously described del instruction is able to delete more than just a list's element at once - it can delete slices too: my_list = [10, 8, 6, 4, 2] del my_list[1:3] print(my_list)
Note: in this case, the slice doesn't produce any new list! The snippet's output is: [10, 4, 2]
A slice of this form makes a new (target) list, taking elements from the source list - the elements of the indices from start to 'end - 1' (flip)
Note: not to end but to 'end - 1'. An element with an index equal to 'end' is the first element which does not take part in the slicing.
example list_1 = [1] list_2 = list_1 list_1[0] = 2 print(list_2) (output: [2]) (flip card)
The assignment: list_2 = list_1 copies the name of the array, not its contents. In effect, the two names (list_1 and list_2) identify the same location in the computer memory. Modifying one of them affects the other, and vice versa
Removing the slice from the code when deleting changes its meaning dramatically. my_list = [10, 8, 6, 4, 2] del my_list print(my_list)
The del instruction will delete the list itself, not its content. The print() function invocation from the last line of the code will then cause a runtime error
Deleting all the elements at once is possible too: my_list = [10, 8, 6, 4, 2] del my_list[:] print(my_list)
The list becomes empty, and the output is: []
example; 'slicing' my_list = [10, 8, 6, 4, 2] new_list = my_list[1:3] print(new_list)
The new_list list will have end - start (3 - 1 = 2) elements - the ones with "indices" equal to 1 and 2 (but not 3). The snippet's output is: [8, 6]
lists slices; with 'negative indices' my_list = [10, 8, 6, 4, 2] new_list = my_list[1:-1] print(new_list) (flip for output)
The snippet's output is: [8, 6, 4]
slices continued; As we've said before, omitting both start and end makes a copy of the whole list my_list = [10, 8, 6, 4, 2] new_list = my_list[:] print(new_list)
The snippet's output is: [10, 8, 6, 4, 2].
Note: we're not going to name it sum as Python uses the same name for one of its built-in functions - sum()
Using the same name would generally be considered a bad practice.
Let's assume that you want to calculate the sum of all the values stored in the my_list list.
You need a variable whose sum will be stored and initially assigned a value of 0 - its name will be total.
example - using append to add to list with for loop. What's the output using print? my_list = [] for i in range(5): *my_list.append(i + 1)
[1, 2, 3, 4, 5]
example my_list = [10, 8, 6, 4, 2] new_list = my_list[ :3] print(new_list)
[10,8,6]
What is the output of the following snippet? lst = [1, [2, 3], 4] print(lst[1]) print(len(lst))
[2, 3] 3
example my_list = [10, 8, 6, 4, 2] new_list = my_list[3 : len(my_list)] print(new_list)
[4, 2]
example - using insert to add to list with for loop. What's the output using print? my_list = [] for i in range(5): *my_list.insert(0, i + 1)
[5, 4, 3, 2, 1]
what is the demonstration of a 'slice' in python? ([:] colon surrounded by brackets)
[:] , colon surrounded by brackets
**key takeaways (beginninggg)
beginningggg
a sorting algorithm that compares two adjacent elements and swaps them until they are in the intended order (bubble sort)
bubble sort
Here's an example of a list comprehension ‒ the code creates a five-element list filled with the first five natural numbers raised to the power of 3:
cubed = [num ** 3 for num in range(5)] print(cubed) # outputs: [0, 1, 8, 27, 64]