Module 1, Practical 3¶

Lists¶

Python lists are ordered collections of (homogeneous) objects, but they can hold also non-homogeneous data. List are mutable objects. Elements of the collection are specified within two square brackets [] and are comma separated.

We can use the function print to print the content of lists. Some examples of list definitions follow:

[1]:

my_first_list = [1,2,3]
print("first:" , my_first_list)

my_second_list = [1,2,3,1,3] #elements can appear several times
print("second: ", my_second_list)

fruits = ["apple", "pear", "peach", "strawberry", "cherry"] #elements can be strings
print("fruits:", fruits)

an_empty_list = []
print("empty:" , an_empty_list)

another_empty_list = list()
print("another empty:", another_empty_list)

a_list_containing_other_lists = [[1,2], [3,4,5,6]] #elements can be other lists
print("list of lists:", a_list_containing_other_lists)

my_final_example = [my_first_list, a_list_containing_other_lists]
print("a list of lists of lists:", my_final_example)

first: [1, 2, 3]
second:  [1, 2, 3, 1, 3]
fruits: ['apple', 'pear', 'peach', 'strawberry', 'cherry']
empty: []
another empty: []
list of lists: [[1, 2], [3, 4, 5, 6]]
a list of lists of lists: [[1, 2, 3], [[1, 2], [3, 4, 5, 6]]]

Operators for lists¶

Python provides several operators to handle lists. The following operators behave like on strings (remember that, as in strings, the first position is 0!):

While this in operator requires that the whole tested obj is present in the list

and

can also change the corresponding value of the list (lists are mutable objects).

Let’s see some examples.

[2]:

A = [1, 2, 3 ]
B = [1, 2, 3, 1, 2]

print("A is a ", type(A))

print(A, " has length: ", len(A))
print("A[0]: ", A[0], " A[1]:", A[1], " A[-1]:", A[-1])

print(B, " has length: ", len(B))
print("Is A equal to B?", A == B)

C = A + [1, 2]
print(C)
print("Is C equal to B?", B == C)   #same content
print("Is C the same object as B?", B is C) #different objects
D = [1, 2, 3]*8
print(D)

E = D[12:18] #slicing
print(E)
print("Is A*2 equal to E?", A*2 == E)

A is a  <class 'list'>
[1, 2, 3]  has length:  3
A[0]:  1  A[1]: 2  A[-1]: 3
[1, 2, 3, 1, 2]  has length:  5
Is A equal to B? False
[1, 2, 3, 1, 2]
Is C equal to B? True
Is C the same object as B? False
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3, 1, 2, 3]
Is A*2 equal to E? True

[3]:

A = [1, 2, 3, 4, 5, 6]
B = [1, 3, 5]
print("A:", A)
print("B:", B)

print("Is B in A?", B in A)
print("A\'s ID:", id(A))
A[5] = [1,3,5] #we can add elements
print(A)
print("A\'s ID:", id(A)) #same as before! why?
print("A has length:", len(A))
print("Is now B in A?", B in A)

A: [1, 2, 3, 4, 5, 6]
B: [1, 3, 5]
Is B in A? False
A's ID: 140661389830592
[1, 2, 3, 4, 5, [1, 3, 5]]
A's ID: 140661389830592
A has length: 6
Is now B in A? True

Consider the following example:

[4]:

A = [1, 2, 3, 4, 5, 6]
print("A has length:", len(A))

print("First element:", A[0])
print("7th-element: ", A[6])

A has length: 6
First element: 1

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Input In [4], in <cell line: 5>()
      2 print("A has length:", len(A))
      4 print("First element:", A[0])
----> 5 print("7th-element: ", A[6])

IndexError: list index out of range

It is actually fine to exceed boundaries with slicing instead:

[5]:

A = [1, 2, 3, 4, 5, 6]
print("A has length:", len(A))

print("First element:", A[0])
print("last element: ", A[-1])

print("3rd to 10th: ", A[2:10])

print("8th to 11th:", A[7:11])

A has length: 6
First element: 1
last element:  6
3rd to 10th:  [3, 4, 5, 6]
8th to 11th: []

let’s try

1. Create an empyt list and verify that its lenght is equal to 0.

2. Create a list with the first five non negative integer (1,2,3,4,5) using range().

3. Create a list with 100 elements equal to 0.

4. Given

lista = [0.0, "b", [3], [4, 5]]

try a) the length of the list. b) the type of the first element of the list. c) the lenght of the second element of the list. d) the lenght of the 3th element of the list. e) lenght of the last element of the list. f) Does the list contains the value “b” (use in). g) does the list contains the value 4?

5. Consider the matrix \(M = \begin{bmatrix}1 & 2 & 3\\ 1 & 2 & 1\\ 1 & 1 & 3\end{bmatrix}\) and the vector \(v=[10, 5, 10]^T\). What is the matrix-vector product \(M*v\)?

   \[\begin{split}\begin{bmatrix}1 & 2 & 3\\ 1 & 2 & 1\\ 1 & 1 & 3\end{bmatrix}*[10,5,10]^T = [50, 30, 45]^T\end{split}\]

[6]:

M = [[1, 2, 3], [1, 2, 1], [1, 1, 3]]
v = [10, 5, 10]
prod = [0, 0 ,0] #at the beginning the product is the null vector

prod[0]=M[0][0]*v[0] + M[0][1]*v[1] + M[0][2]*v[2]
prod[1]=M[1][0]*v[0] + M[1][1]*v[1] + M[1][2]*v[2]
prod[2]=M[2][0]*v[0] + M[2][1]*v[1] + M[2][2]*v[2]

print("M: ", M)
print("v: ", v)
print("M*v: ", prod)

M:  [[1, 2, 3], [1, 2, 1], [1, 1, 3]]
v:  [10, 5, 10]
M*v:  [50, 30, 45]

Methods of the class list¶

The class list has some methods that can be used to operate on it. Recall from the lecture the following methods:

Some usage examples follow:

[7]:

#A numeric list
A = [1, 2, 3]
print(A)
print("A has id:", id(A))
A.append(72) #appends one and only one object
print(A)
print("A has id:", id(A))
A.extend([1, 5, 124, 99]) #adds all these objects, one after the other.
print(A)
A.reverse() #NOTE: NO RETURN VALUE!!!
print(A)
A.sort()
print(A)
print("Min value: ", A[0]) # In this simple case, could have used min(A)
print("Max value: ", A[-1]) #In this simple case, could have used max(A)
print("Number 1 appears:", A.count(1), " times")
print("While number 837: ", A.count(837))

print("\nDone with numbers, let's go strings...\n")
#A string list
fruits = ["apple", "banana", "pineapple", "cherry","pear", "almond", "orange"]
#Let's get a reverse lexicographic order:
print(fruits)
fruits.sort()
fruits.reverse() # equivalent to: fruits.sort(reverse=True)
print(fruits)
fruits.remove("banana")
print(fruits)
fruits.insert(5, "wild apple") #put wild apple after apple.
print(fruits)
print("\nSorted fruits:")
fruits.sort() # does not return anything. Modifies list!
print(fruits)

[1, 2, 3]
A has id: 140661389498624
[1, 2, 3, 72]
A has id: 140661389498624
[1, 2, 3, 72, 1, 5, 124, 99]
[99, 124, 5, 1, 72, 3, 2, 1]
[1, 1, 2, 3, 5, 72, 99, 124]
Min value:  1
Max value:  124
Number 1 appears: 2  times
While number 837:  0

Done with numbers, let's go strings...

['apple', 'banana', 'pineapple', 'cherry', 'pear', 'almond', 'orange']
['pineapple', 'pear', 'orange', 'cherry', 'banana', 'apple', 'almond']
['pineapple', 'pear', 'orange', 'cherry', 'apple', 'almond']
['pineapple', 'pear', 'orange', 'cherry', 'apple', 'wild apple', 'almond']

Sorted fruits:
['almond', 'apple', 'cherry', 'orange', 'pear', 'pineapple', 'wild apple']

An important thing to remember that we mentioned already a couple of times is that lists are mutable objects and therefore virtually all the previous methods (except count) do not have an output value:

[8]:

A = ["A", "B", "C"]

print("A:", A)

A_new = A.append("D")

print("A:", A)

print("A_new:", A_new)

#A_new is None. We cannot apply methods to it...
print(A_new is None)
print("A_new has " , A_new.count("D"), " Ds")

A: ['A', 'B', 'C']
A: ['A', 'B', 'C', 'D']
A_new: None
True

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In [8], in <cell line: 13>()
     11 #A_new is None. We cannot apply methods to it...
     12 print(A_new is None)
---> 13 print("A_new has " , A_new.count("D"), " Ds")

AttributeError: 'NoneType' object has no attribute 'count'

[9]:

A = [1, 2, 3]
A.extend([4, 5])
print(A)
B = [1, 2, 3]
B.append([4,5])
print(B)

[1, 2, 3, 4, 5]
[1, 2, 3, [4, 5]]

[10]:

A = [1,2,3, [[4],[5,6]], 8]
print(A)
A.remove(2)
print(A)
A.remove([[4],[5,6]])
print(A)
A.remove(7)

[1, 2, 3, [[4], [5, 6]], 8]
[1, 3, [[4], [5, 6]], 8]
[1, 3, 8]

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [10], in <cell line: 7>()
      5 A.remove([[4],[5,6]])
      6 print(A)
----> 7 A.remove(7)

ValueError: list.remove(x): x not in list

[11]:

A = [4,3, 1,7, 2]
print("A:", A)
A.sort()
print("A sorted:",  A)
A.append("banana")
print("A:", A)
A.sort()
print("A:", A)

A: [4, 3, 1, 7, 2]
A sorted: [1, 2, 3, 4, 7]
A: [1, 2, 3, 4, 7, 'banana']

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [11], in <cell line: 7>()
      5 A.append("banana")
      6 print("A:", A)
----> 7 A.sort()
      8 print("A:", A)

TypeError: '<' not supported between instances of 'str' and 'int'

[12]:

l1 = [1, 2]
l2 = [4, 3]
LL = [l1, l2]
print("l1:", l1)
print("l2:",l2)
print("LL:", LL)
l1.append(7)
print("\nAppending 7 to l1...")
print("l1:", l1)
print("LL now: ", LL)

LL[0][1] = -1
print("\nSetting LL[0][1]=-1...")
print("LL now:" , LL)
print("l1 now", l1)
#but the list can point also to a different object,
#without affecting the original list.
LL[0] = 100
print("\nSetting LL[0] = 100")
print("LL now:", LL)
print("l1 now", l1)

l1: [1, 2]
l2: [4, 3]
LL: [[1, 2], [4, 3]]

Appending 7 to l1...
l1: [1, 2, 7]
LL now:  [[1, 2, 7], [4, 3]]

Setting LL[0][1]=-1...
LL now: [[1, -1, 7], [4, 3]]
l1 now [1, -1, 7]

Setting LL[0] = 100
LL now: [100, [4, 3]]
l1 now [1, -1, 7]

[13]:

A = ["hi", "there"]
B = A
print("A:", A)
print("B:", B)
A.extend(["from", "python"])
print("A now: ", A)
print("B now: ", B)

print("\n---- copy example -------")
#Let's make a distinct copy of A.
C = A[:] #all the elements of A have been copied in C
print("C:", C)
A[3] = "java"
print("A now:", A)
print("C now:", C)

print("\n---- be careful though -------")
#Watch out though that this is a shallow copy...
D = [A, A]
E = D[:]
print("D:", D)
print("E:", E)

D[0][0] = "hello"
print("\nD now:", D)
print("E now:", E)
print("A now:", A)

A: ['hi', 'there']
B: ['hi', 'there']
A now:  ['hi', 'there', 'from', 'python']
B now:  ['hi', 'there', 'from', 'python']

---- copy example -------
C: ['hi', 'there', 'from', 'python']
A now: ['hi', 'there', 'from', 'java']
C now: ['hi', 'there', 'from', 'python']

---- be careful though -------
D: [['hi', 'there', 'from', 'java'], ['hi', 'there', 'from', 'java']]
E: [['hi', 'there', 'from', 'java'], ['hi', 'there', 'from', 'java']]

D now: [['hello', 'there', 'from', 'java'], ['hello', 'there', 'from', 'java']]
E now: [['hello', 'there', 'from', 'java'], ['hello', 'there', 'from', 'java']]
A now: ['hello', 'there', 'from', 'java']

[14]:

A = [1, 2, 3]
B = A
C = [1, 2, 3]
print("Is A equal to B?", A == B)
print("Is A actually B?", A is B)
print("Is A equal to C?", A == C)
print("Is A actually C?", A is C)
#in fact:
print("\nA's id:", id(A))
print("B's id:", id(B))
print("C's id:", id(C))
#just to confirm that:
A.append(4)
B.append(5)
print("\nA now: ", A)
print("B now: ", B)
print("C now:", C)

Is A equal to B? True
Is A actually B? True
Is A equal to C? True
Is A actually C? False

A's id: 140661388695936
B's id: 140661388695936
C's id: 140661388700608

A now:  [1, 2, 3, 4, 5]
B now:  [1, 2, 3, 4, 5]
C now: [1, 2, 3]

lista = []
lista.append(list(range(10)))
lista.append(list(range(10, 20)))

lista = []
lista.extend(list(range(10)))
lista.extend(list(range(10, 20)))

lista = [1, 2, 3, 4, 5]
lista.reverse()
lista.sort()

lista = [1, 2, 3, 4, 5]
lista.reverse().sort()

fragments = [
    "KSYK",
    "SVALVV",
    "GVTGI",
    "VGSSLAEVLKLPD",
]

text = ["Hello","how","are","you","?","?"]

From strings to lists (split method)¶

Strings have a method split that can literally split the string at specific characters.

Example

Recall the protein seen in the previous practical:

chain_a = """SSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKM
FCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVV
RRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFR
HSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILT
IITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKG
EPHHELPPGSTKRALPNNT"""

how can we split it into several lines?

[15]:

chain_a = """SSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKM
FCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVV
RRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFR
HSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILT
IITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKG
EPHHELPPGSTKRALPNNT"""

lines = chain_a.split('\n')
print("Original sequence:")
print( chain_a, "\n") #some spacing to keep things clear
print("line by line:")
# write the following and you will appreciate loops! :-)
print("1st line:" ,lines[0])
print("2nd line:" ,lines[1])
print("3rd line:" ,lines[2])
print("4th line:" ,lines[3])
print("5th line:" ,lines[4])
print("6th line:" ,lines[5])

print("\nSplit the 1st line in correspondence of FRL:\n",lines[0].split("FRL"))

Original sequence:
SSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKM
FCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVV
RRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFR
HSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILT
IITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKG
EPHHELPPGSTKRALPNNT

line by line:
1st line: SSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKM
2nd line: FCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVV
3rd line: RRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFR
4th line: HSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILT
5th line: IITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKG
6th line: EPHHELPPGSTKRALPNNT

Split the 1st line in correspondence of FRL:
 ['SSSVPSQKTYQGSYG', 'GFLHSGTAKSVTCTYSPALNKM']

Note that in the last instruction, the substring FRL is disappeared (as happened to the newline).

from list to strings (join method)¶

Given a list, one can join the elements of the list together into a string by using the join method of the class string. The syntax is the following: str.join(list) which joins together all the elements in the list in a string separating them with the string str.

Example Given the list [‘Sept’, ‘30th’, ‘2020’, ‘11:30’], let’s combine all its elements in a string joining the elements with a dash (“-”) and print them. Let’s finally join them with a tab (”\t”) and print them.

[16]:

vals = ['Sept', '30th', '2020', '11:30']
print(vals)
myStr = "-".join(vals)
print("\n" + myStr)
myStr = "\t".join(vals)
print("\n" + myStr)

['Sept', '30th', '2020', '11:30']

Sept-30th-2020-11:30

Sept    30th    2020    11:30

let’s try

1. Given

testo = """The Wellcome Trust Sanger Institute
is a world leader in genome research."""

Create a list of for each word. Print the number of words in the list. Create a variable first_row containing the first line, do the same for the second row. Print the second word of the second row.

2. Given

tabella = [
    "protein | database | domain | start | end",
    "YNL275W | Pfam | PF00955 | 236 | 498",
    "YHR065C | SMART | SM00490 | 335 | 416",
    "YKL053C-A | Pfam | PF05254 | 5 | 72",
    "YOR349W | PANTHER | 353 | 414",
]

The first row contains the names of the colomns. Put each elemnet of the first row in a list.

Exercises (LIST)¶

1. Given a list, write a Python program to swap first and last element of the list. input [1,2,3,4,5] output [5,2,3,4,1]

[24]:

list1 = [1,2,3,4,5]

pos_0_newList = [list1[-1]] #  because do we need to put list[-1] into a list?
content_newList = list1[1:-1]
pos_end_newList = [list1[0]]
newList =  pos_0_newList + content_newList + pos_end_newList
print(newList)

[5, 2, 3, 4, 1]

2. We are given a list of numbers and our task is to write a Python program to find the smallest number in given list. Do not use min() :)

[26]:

list1 = [1,10,439,10,0,-58,39]
list1.sort()
min_val = list1[0]
print(min_val)

-58

3. We are given a list of words

test_list = ['Gfg', 'is', 'best', 'for', 'Geeks']

substitute each “G” with an “e” and each “e” with a “G” output

res = ['efg', 'is', 'bGst', 'for', 'eGGks']

[31]:

test_list = ['Gfg', 'is', 'best', 'for', 'Geeks']

res = ", ".join(test_list)
print(res)
res = res.replace("G","_")
print(res)
res = res.replace("e","G")
print(res)
res = res.replace("_","e")

res_list = res.split(",")
print(res_list)

Gfg, is, best, for, Geeks
_fg, is, best, for, _eeks
_fg, is, bGst, for, _GGks
['efg', ' is', ' bGst', ' for', ' eGGks']

Tuples¶

Tuples are the immutable version of lists (i.e. it is not possible to change their content without actually changing the object). They are sequential collections of objects, and elements of tuples are assumed to be in a particular order. They can hold heterogeneous information. They are defined with the brackets (). Some examples:

[17]:

first_tuple = (1,2,3)
print(first_tuple)

second_tuple = (1,) #this contains one element only, but we need the comma!
var = (1) #This is not a tuple!!!
print(second_tuple, " type:", type(second_tuple))
print(var, " type:", type(var))
empty_tuple = () #fairly useless
print(empty_tuple, "\n")
third_tuple = ("January", 1 ,2007) #heterogeneous info
print(third_tuple)

days = (third_tuple,("February",2,1998), ("March",2,1978),("June",12,1978))
print(days, "\n")

#Remember tuples are immutable objects...
print("Days has id: ", id(days))
days = ("Mon","Tue","Wed","Thu","Fri","Sat","Sun")
#...hence reassignment creates a new object
print("Days now has id: ", id(days))

(1, 2, 3)
(1,)  type: <class 'tuple'>
1  type: <class 'int'>
()

('January', 1, 2007)
(('January', 1, 2007), ('February', 2, 1998), ('March', 2, 1978), ('June', 12, 1978))

Days has id:  140163619270672
Days now has id:  140163619232960

The following operators work on tuples and they behave exactly as on lists:

[18]:

practical1 = ("Wednesday", "23/09/2020")
practical2 = ("Monday", "28/09/2020")
practical3 = ("Wednesday", "30/09/2020")

#A tuple containing 3 tuples
lectures = (practical1, practical2, practical3)
#One tuple only
mergedLectures = practical1 + practical2 + practical3

print("The first three lectures:\n", lectures, "\n")
print("mergedLectures:\n", mergedLectures)

#This returns the whole tuple
print("1st lecture was on: ", lectures[0], "\n")
#2 elements from the same tuple
print("1st lecture was on ", mergedLectures[0], ", ", mergedLectures[1], "\n")
# Return type is tuple!
print("3rd lecture was on: ", lectures[2])
#2 elements from the same tuple returned in tuple
print("3rd lecture was on ", mergedLectures[4:], "\n")

The first three lectures:
 (('Wednesday', '23/09/2020'), ('Monday', '28/09/2020'), ('Wednesday', '30/09/2020'))

mergedLectures:
 ('Wednesday', '23/09/2020', 'Monday', '28/09/2020', 'Wednesday', '30/09/2020')
1st lecture was on:  ('Wednesday', '23/09/2020')

1st lecture was on  Wednesday ,  23/09/2020

3rd lecture was on:  ('Wednesday', '30/09/2020')
3rd lecture was on  ('Wednesday', '30/09/2020')

The following methods are available for tuples:

[19]:

practical1 = ("Wednesday", "23/09/2020")
practical2 = ("Monday", "28/09/2020")
practical3 = ("Wednesday", "30/09/2020")


mergedLectures = practical1 + practical2 + practical3  #One tuple only
print(mergedLectures.count("Wednesday"), " lectures were on Wednesday")
print(mergedLectures.count("Monday"), " lecture was on Monday")
print(mergedLectures.count("Friday"), " lectures was on Friday")

print("Index:", practical2.index("Monday"))
#You cannot look for an element that does not exist
print("Index:", practical2.index("Wednesday"))

2  lectures were on Wednesday
1  lecture was on Monday
0  lectures was on Friday
Index: 0

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [19], in <cell line: 13>()
     11 print("Index:", practical2.index("Monday"))
     12 #You cannot look for an element that does not exist
---> 13 print("Index:", practical2.index("Wednesday"))

ValueError: tuple.index(x): x not in tuple

Introduction to sets¶

Python also includes a data type for sets. A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.

Curly braces or the set() function can be used to create sets. Note: to create an empty set you have to use set(), not {}; the latter creates an empty dictionary, a data structure that we will discuss in the next practicals.

Here is a brief demonstration:

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

Exercises¶

1. Given the following text string:

"""this is a text
string on
several lines that does not say anything."""

• print it;

• print how many lines, words and characters it contains;

• sort the words alphabetically and print the first and the last in lexicographic order.

[20]:

T = """this is a text
string on
several lines that does not say anything."""

#a) print it
print(T)
print("")
#b) print the lines, words and characters
lines = T.split('\n')

#NOTE: words are split by a space or a newline! They have already been
#split by newline.

words = lines[0].split(' ') + lines[1].split(' ') + lines[2].split(' ')

num_chars = len(T) #this includes spaces and newlines

print("Lines:", len(lines), "words:", len(words), "chars:", num_chars)
# alternative way for number of characters:
print("")
characters = list(T) #put all the characters of the string in a list
num_chars2 = len(characters)
print(characters)
print(num_chars2)

print("Unsorted words: ", words)
words.sort() #NOTE: it does not return ANYTHING!!!
print("\nSorted words: ", words)
print("")
print("First word: ", words[0])
print("Last word:", words[-1])

this is a text
string on
several lines that does not say anything.

Lines: 3 words: 13 chars: 66

['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 'x', 't', '\n', 's', 't', 'r', 'i', 'n', 'g', ' ', 'o', 'n', '\n', 's', 'e', 'v', 'e', 'r', 'a', 'l', ' ', 'l', 'i', 'n', 'e', 's', ' ', 't', 'h', 'a', 't', ' ', 'd', 'o', 'e', 's', ' ', 'n', 'o', 't', ' ', 's', 'a', 'y', ' ', 'a', 'n', 'y', 't', 'h', 'i', 'n', 'g', '.']
66
Unsorted words:  ['this', 'is', 'a', 'text', 'string', 'on', 'several', 'lines', 'that', 'does', 'not', 'say', 'anything.']

Sorted words:  ['a', 'anything.', 'does', 'is', 'lines', 'not', 'on', 'say', 'several', 'string', 'text', 'that', 'this']

First word:  a
Last word: this

2. You are given a string s. The score of a string is defined as the sum of the absolute difference between the ASCII values of adjacent characters. Print the score of s.

Example:

Input: s = “hello”

Output: 13

Explanation:

The ASCII values of the characters in s are: ‘h’ = 104, ‘e’ = 101, ‘l’ = 108, ‘o’ = 111. So, the score of s would be |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13.

hint to get the ASCII number use ord(x), where x is a character.

[6]:

s = "test"
score = 0
for i in range(len(s) - 1):
    score += abs(ord(s[i]) - ord(s[i + 1]))
print("Score of string:", score)

Score of string: 30

3. Given the list L = [“walnut”, “eggplant”, “lemon”, “lime”, “date”, “onion”, “nectarine”, “endive” ]:

• Create another list (called newList) containing the first letter of each element of L (e.g newList =[“w”, “e”, …]).

• Add a space to newList at position 4 and append an exclamation mark (!) at the end.

• Print the list.

• Print the content of the list joining all the elements with an empty space (i.e. use the method join: “”.join(newList) )

[29]:

L = ["walnut", "eggplant", "lemon", "lime", "date", "onion", "nectarine", "endive" ]

newList = []
#the next few lines are to make you appreciate loops! :-)
newList.append(L[0][0])
newList.append(L[1][0])
newList.append(L[2][0])
newList.append(L[3][0])
newList.append(L[4][0])
newList.append(L[5][0])
newList.append(L[6][0])
newList.append(L[7][0])

newList.insert(4," ")
newList.append("!")

print(newList)
print("\n", "".join(newList))

['w', 'e', 'l', 'l', ' ', 'd', 'o', 'n', 'e', '!']

 well done!

4. Goal Parser Interpretation: You own a Goal Parser that can interpret a string command. The command consists of an alphabet of “G”, “()”, and/or “(al)” in some order.

The Goal Parser interprets: - "G" → "G" - "()" → "o" - "(al)" → "al"

The interpreted strings are then concatenated in the original order.

Task Given the string command, return the Goal Parser’s interpretation of command.

Examples

[ ]:

command = "G()(al)"          # Goal
command = "G()()()()(al)"    # Gooooal
command = "(al)G(al)()()G"   # alGalooG

result = []
i = 0
while i < len(command):
    if command[i] == 'G':
        result.append('G')
        i += 1
    elif command[i:i+2] == '()':
        result.append('o')
        i += 2
    else:  # must be "(al)"
        result.append('al')
        i += 4
result =  ''.join(result)
print(result)

alGalooG

5. Given the list L = [10, 60, 72, 118, 11, 71, 56, 89, 120, 175] find the min, max and median value (hint: sort it and extract the right values). Create a list with only the elements at even indexes (i.e. [10, 72, 11, ..], note that the “..” means that the list is not complete) and re-compute min, max and median values. Finally, re-do the same for the elements located at odd indexes (i.e. [60, 118,..]).

[1]:

L = [10, 60, 72, 118, 11, 71, 56, 89, 120, 175]
Lodd = L[1::2] #get only odd-indexed elements
Leven = L[0::2] #get only even-indexed elements

print("original:" , L)
print("Lodd:", Lodd)
print("Leven:", Leven)
L.sort()
Lodd.sort()
Leven.sort()


print("sorted:  " , L)
print("sorted Lodd:  " , Lodd)
print("sorted Leven:  " , Leven)

print("L: Min: ", L[0], " Max." , L[-1], " Median: ", L[len(L) // 2])
print("Lodd: Min: ", Lodd[0], " Max." , Lodd[-1], " Median: ", Lodd[len(Lodd) // 2])
print("Leven: Min: ", Leven[0], " Max." , Leven[-1], " Median: ", Leven[len(Leven) // 2])

original: [10, 60, 72, 118, 11, 71, 56, 89, 120, 175]
Lodd: [60, 118, 71, 89, 175]
Leven: [10, 72, 11, 56, 120]
sorted:   [10, 11, 56, 60, 71, 72, 89, 118, 120, 175]
sorted Lodd:   [60, 71, 89, 118, 175]
sorted Leven:   [10, 11, 56, 72, 120]
L: Min:  10  Max. 175  Median:  72
Lodd: Min:  60  Max. 175  Median:  89
Leven: Min:  10  Max. 120  Median:  56

6. Given the string pets = “siamese cat,dog,songbird,guinea pig,rabbit,hampster” convert it into a list. Create then a tuple of tuples where each tuple has two information: the name of the pet and the length of the name. E.g. ((“dog”,3), ( “hampster”,8)). Print the tuple.

[23]:

pets = "cat,dog,bird,guinea pig,rabbit,hampster"

pet_list = pets.split(',')

print(pet_list)

pet_tuples = ((pet_list[0], len(pet_list[0])),
              (pet_list[1], len(pet_list[1])),
              (pet_list[2], len(pet_list[2])),
              (pet_list[3], len(pet_list[3])),
              (pet_list[4], len(pet_list[4])),
              (pet_list[5], len(pet_list[5])))

print(pet_tuples)

['cat', 'dog', 'bird', 'guinea pig', 'rabbit', 'hampster']
(('cat', 3), ('dog', 3), ('bird', 4), ('guinea pig', 10), ('rabbit', 6), ('hampster', 8))

7. Given the string S=”apple|pear|apple|cherry|pear|apple|pear|pear|cherry|pear|strawberry”. Store the elements separated by the “|” in a list.

   1. How many elements does the list have?

   2. Knowing that the list created at the previous point has only four distinct elements (i.e. “apple”,”pear”,”cherry” and “strawberry”), create another list where each element is a tuple containing the name of the fruit and its multiplicity (that is how many times it appears in the original list). Ex. list_of_tuples = [(“apple”, 3), (“pear”, “5”),…]

   3. Print the content of each tuple in a separate line (ex. first line: apple is present 3 times)

[24]:

S="apple|pear|apple|cherry|pear|apple|pear|pear|cherry|pear|strawberry"

Slist = S.split("|")
print(Slist)

appleT = ("apple", Slist.count("apple"))
pearT = ("pear", Slist.count("pear"))
cherryT = ("cherry", Slist.count("cherry"))
strawberryT = ("strawberry", Slist.count("strawberry"))
list_of_tuples =[appleT, pearT, cherryT, strawberryT]

print(list_of_tuples, "\n") #adding newline to separate elements

print(appleT[0], " is present ", appleT[1], " times")
print(pearT[0], " is present ", pearT[1], " times")
print(cherryT[0], " is present ", cherryT[1], " times")
print(strawberryT[0], " is present ", strawberryT[1], " times")

['apple', 'pear', 'apple', 'cherry', 'pear', 'apple', 'pear', 'pear', 'cherry', 'pear', 'strawberry']
[('apple', 3), ('pear', 5), ('cherry', 2), ('strawberry', 1)]

apple  is present  3  times
pear  is present  5  times
cherry  is present  2  times
strawberry  is present  1  times

8. Define three tuples representing points in the 3D space: A = (10,20,30), B = (1,72, 100) and C = (4, 9, 20).

   1. Compute the Euclidean distance between A and B (let’s call it AB), A and C (AC), B and C (BC) and print them. Remember that the distance \(d\) between two points \(X_1 = (x_1,y_1,z_1)\) and \(X_2 = (x_2,y_2,z_2)\) is \(d = \sqrt{(x_2-x_1)^2 + (y_2 - y_1)^2 + (z_2-z_1)^2}\). Hint: remember to import math to use the sqrt method.

   2. Create a point D multiplying every element of C by 10. (Hint: do not use C*10, as this will repeat C 10 times). And compute the distance AD, BD, CD.

   3. Answer to the following questions (writing a suitable boolean expression and printing the result):

      1. Is A closer to B than to C?

      2. Is A closer to C than to B or to D?

      3. Is B closer to A than to C to D?

[25]:

import math

A = (10,20,30)
B = (1,72, 100)
C = (4,9,20)
D = (C[0]*10, C[1]*10, C[2]*10)

AB = math.sqrt( (B[0]-A[0])**2 + (B[1] - A[1])**2 + (B[2] - A[2])**2)
AC = math.sqrt( (C[0]-A[0])**2 + (C[1] - A[1])**2 + (C[2] - A[2])**2)
BC = math.sqrt( (C[0]-B[0])**2 + (C[1] - B[1])**2 + (C[2] - B[2])**2)
AD = math.sqrt( (D[0]-A[0])**2 + (D[1] - A[1])**2 + (D[2] - A[2])**2)
BD = math.sqrt( (D[0]-B[0])**2 + (D[1] - B[1])**2 + (D[2] - B[2])**2)
CD = math.sqrt( (D[0]-C[0])**2 + (D[1] - C[1])**2 + (D[2] - C[2])**2)

print("Distance AB: ", AB)
print("Distance AC: ", AC)
print("Distance AD: ", AD)
print("Distance BC: ", BC)
print("Distance BD: ", BD)
print("Distance CD: ", CD)

print("A is closer to B than to C: ", AB < AC)
print("A is closer to C than to B or D:", AC < AB and AC < AD)
print("B is closer to A than C to D:", AB < CD)

Distance AB:  87.66413177577246
Distance AC:  16.0312195418814
Distance AD:  186.27936010197158
Distance BC:  101.87246929372037
Distance BD:  108.83473710171766
Distance CD:  200.64147128647159
A is closer to B than to C:  False
A is closer to C than to B or D: True
B is closer to A than C to D: True

9. Given the matrix \(M =\begin{bmatrix}1 & 2 & 3\\ 4 & 5 & 6\\ 7 & 8 & 9\end{bmatrix}\) compute \(M^2 = \begin{bmatrix}1 & 2 & 3\\ 4 & 5 & 6\\ 7 & 8 & 9\end{bmatrix} \times \begin{bmatrix}1 & 2 & 3\\ 4 & 5 & 6\\ 7 & 8 & 9\end{bmatrix} = \begin{bmatrix}30 & 36 & 42\\ 66 & 81 & 96\\ 102 & 126 & 150\end{bmatrix}\)

[26]:

M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Msq = [[0, 0, 0], [0, 0,0], [0, 0, 0]]# the output is initialized to the zero matrix
#Msq[i,j] is represented as Msq[i][j]
Msq[0][0] = M[0][0]*M[0][0] + M[0][1]*M[1][0] + M[0][2] * M[2][0]
Msq[0][1] = M[0][0]*M[0][1] + M[0][1]*M[1][1] + M[0][2] * M[2][1]
Msq[0][2] = M[0][0]*M[0][2] + M[0][1]*M[1][2] + M[0][2] * M[2][2]
Msq[1][0] = M[1][0]*M[0][0] + M[1][1]*M[1][0] + M[1][2] * M[2][0]
Msq[1][1] = M[1][0]*M[0][1] + M[1][1]*M[1][1] + M[1][2] * M[2][1]
Msq[1][2] = M[1][0]*M[0][2] + M[1][1]*M[1][2] + M[1][2] * M[2][2]
Msq[2][0] = M[2][0]*M[0][0] + M[2][1]*M[1][0] + M[2][2] * M[2][0]
Msq[2][1] = M[2][0]*M[0][1] + M[2][1]*M[1][1] + M[2][2] * M[2][1]
Msq[2][2] = M[2][0]*M[0][2] + M[2][1]*M[1][2] + M[2][2] * M[2][2]

print(Msq)

[[30, 36, 42], [66, 81, 96], [102, 126, 150]]

10. Given a list, count the number of unique elements input

data = [1,1,1,3,3,3,2,1,2]

output

nb unique elements = 3

[8]:

data = [1,1,1,3,3,3,2,1,2]

print(len(set(data)))

3

11. Given a List, extract all elements whose frequency is greater than K.

input

test_list = [4, 6, 4, 3, 3, 4, 3, 4, 3, 8], K = 3

output

[4,3]

[9]:

test_list = [4, 6, 4, 3, 3, 4, 3, 4, 3, 8]
K = 3
res = []
for i in set(test_list):
    count = test_list.count(i)

    if count > K:
        res.append(i)
print(res)

[3, 4]

12. Given two pists, create a list of tuples containing all possible UNIQUE combinations of the lists

input

a = ["a","b","c","a"]
b = [1,2,3]

output

[('c', 3), ('b', 1), ('c', 2), ('a', 2), ('a', 1), ('b', 3), ('c', 1), ('a', 3), ('b', 2)]

[10]:

a = ["a","b","c","a"]
b = [1,2,3]

res = []
for i in a:
    for j in b:
        res.append((i,j))

res = list(set(res))
print(res)

[('c', 2), ('a', 2), ('b', 3), ('c', 1), ('a', 1), ('b', 2), ('c', 3), ('a', 3), ('b', 1)]

13. Given a list, K and N, create a list of tuples containing elements with K appearing at least N times.

input

test_list = [(4, 5, 5, 4), (5, 4, 3)]
K = 5
N = 2

output

[(4, 5, 5, 4)]

[11]:

test_list = [(4, 5, 5, 4), (5, 4, 3)]
K = 5
N = 2

res = []
for i in test_list:
    to_keep = False
    count = i.count(K)
    if count >= N:
        res.append(i)
print (res)

[(4, 5, 5, 4)]

13. Given a list, split every K elements, if len(list)/K is not an integer, then the last element should contain the rest

input

test_list = [1,2,3,4,5,6,7,8,9,10]
K = 3

output

[[1,2,3],[4,5,6],[7,8,9],[10]]

[12]:

test_list = [1,2,3,4,5,6,7,8,9,10]
k = 3
counter = 0
tmp = []
res = []
for i in test_list:
    if counter <k:
        counter += 1
        tmp.append(i)
    else:
        res.append(tmp)
        tmp = []
        tmp.append(i)
        counter = 1

if tmp != []:
    res.append(tmp)

print(res)

[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

Exercises (difficult)¶

1. You are given two strings s and t such that every character occurs at most once in s and t is a permutation of s.

The permutation difference between s and t is defined as the sum of the absolute difference between the index of the occurrence of each character in s and the index of the occurrence of the same character in t.

Return the permutation difference between s and t.

Example 1:

Input: s = “abc”, t = “bac”

Output: 2

Explanation:

For s = “abc” and t = “bac”, the permutation difference of s and t is equal to the sum of:

• The absolute difference between the index of the occurrence of “a” in s and the index of the occurrence of “a” in t.

• The absolute difference between the index of the occurrence of “b” in s and the index of the occurrence of “b” in t.

• The absolute difference between the index of the occurrence of “c” in s and the index of the occurrence of “c” in t.

That is, the permutation difference between s and t is equal to |0 - 1| + |1 - 0| + |2 - 2| = 2.

[3]:

s = "abc"
t = "bac"

# Map: Character -> index in s
pos_in_s = {ch: i for i, ch in enumerate(s)}

# Sum of absolute differences on indices
total = 0
for j, ch in enumerate(t):
    total += abs(pos_in_s[ch] - j)

#if you don't like enumerate:
# for j in range(len(t)):
#     ch = t[j]
#     total += abs(pos_in_s[ch] - j)
print(total)

2

2. There is a snake in an n x n matrix grid and can move in four possible directions. Each cell in the grid is identified by the position: grid[i][j] = (i * n) + j.

The snake starts at cell 0 and follows a sequence of commands.

Return the position of the final cell where the snake ends up after executing commands.

Example 1

Explanation

Example 2

Explanation

[8]:

"""
Given an n x n grid where each cell's value is (i * n + j),
find the final position of a snake starting at cell 0
after following the movement commands.
The snake always stays inside the grid.

:param n: size of the grid (n x n)
:param commands: list of movement commands ("UP", "DOWN", "LEFT", "RIGHT")
:print: integer position of the final cell
"""

n = 2 # 3
commands = ["RIGHT", "DOWN"] # ["DOWN", "RIGHT", "UP"]


# Start at the top-left corner: row = 0, column = 0
row, col = 0, 0

# Process each command and update the snake's position
for cmd in commands:
    if cmd == "UP":
        row -= 1          # move one cell up
    elif cmd == "DOWN":
        row += 1          # move one cell down
    elif cmd == "LEFT":
        col -= 1          # move one cell left
    elif cmd == "RIGHT":
        col += 1          # move one cell right
    # No need to check boundaries, as guaranteed by the problem

# Convert final (row, col) back to cell number = row * n + col
print(row * n + col)

3

3. Given a 2D integer array matrix, return the transpose of matrix.

Example 1

Example 2

[11]:

"""
Return the transpose of a given 2D integer array (matrix)
without using Python's built-in zip function.

The transpose of a matrix is obtained by flipping it over
its main diagonal, turning rows into columns.
"""

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# matrix = [[1, 2, 3], [4, 5, 6]]



# Number of rows and columns in the input matrix
rows = len(matrix)
cols = len(matrix[0])

# Create a new matrix with reversed dimensions: cols x rows
transposed = [[0] * rows for _ in range(cols)]

# Fill the transposed matrix
for r in range(rows):
    for c in range(cols):
        # Element at (r, c) in the original matrix
        # goes to (c, r) in the transposed matrix
        transposed[c][r] = matrix[r][c]

print(transposed)

[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

4. Every valid email consists of a local name and a domain name, separated by the @ sign. Besides lowercase letters, the email may contain one or more . or +.

For example, in alice@leetcode.com, alice is the local name, and leetcode.com is the domain name.

assert 1 <= len(emails) <= 100, "emails length out of range"
for e in emails:
    assert 1 <= len(e) <= 100, "single email length out of range"

[14]:

# Example 1
emails = [
    "test.email+alex@leetcode.com",
    "test.e.mail+bob.cathy@leetcode.com",
    "testemail+david@lee.tcode.com"
]
# Example 2
#emails = ["a@leetcode.com", "b@leetcode.com", "c@leetcode.com"]


"""
Print the number of unique email addresses that actually receive mails,
applying the '.' and '+' filtering rules to the local name of each email.
"""
# Optional: enforce constraints using assert
assert 1 <= len(emails) <= 100, "emails length out of range"

unique = set()  # will store normalized email addresses

for e in emails:
    assert 1 <= len(e) <= 100, "single email length out of range"
    assert e.count('@') == 1, "invalid email format"

    local, domain = e.split('@')

    # Ignore everything after the first '+' in the local name
    if '+' in local:
        local = local[:local.index('+')]

    # Remove all '.' characters in the local name
    local = local.replace('.', '')

    # Reconstruct the normalized email and add it to the set
    normalized = local + '@' + domain
    unique.add(normalized)

# The number of unique normalized emails equals the count of real receivers
print(len(unique))

2