Module 1, Practical 2¶

Modules¶

Python modules are simply text files having the extension .py (e.g. exercise.py). When you were writing the code in the IDE in the previous practical, you were in fact implementing a module.

As said in the previous practical, once you implemented and saved the code of the module, you can execute it by typing

python3 exercise1.py

(which in Windows might be python exercise1.py, just make sure you are using python 3.x) or, in Visual Studio Code, by right clicking on the code panel and selecting Run Python File in Terminal.

For instance math is a module, and it has many functions:

1. math.sqrt() -> square root

2. math.cos() -> cosine

3. math.log() -> log (base E)

We have to import the module before use it, with:

[2]:

import math

let’s try

Write a program that compute the square root of 4:

[3]:

import math

res = math.sqrt(4)
print(res)

2.0

[5]:

import math

input_value = input("insert a number ")
input_value = int(input_value)

sq = math.sqrt(input_value)
log = math.log(input_value)
cos = math.cos(input_value)

print(sq,log,cos)

7.0710678118654755 3.912023005428146 0.9649660284921133

2. Why those codes are not working?

[ ]:

#########################
# 1
res = math.sqrt(4)
import math
print(res)

#########################
# 2
import math
input_val = input("insert a number")
res = math.sqrt(4)
print(res)

Objects¶

Python understands very well objects, and in fact everything is an object in Python.

Objects have properties (characteristic features) and methods (things they can do). For example, an object car could be defined to have the properties model, make, color, number of doors, position etc., and the methods steer right, steer left, accelerate, break, stop, change gear, repaint,… whose application might affect the state of the object.

According to Python’s official documentation:

“Objects are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects.”

All you need to know for now is that in Python objects have an identifier (ID) (i.e. their name), a type (numbers, text, collections,…) and a value (the actual data represented by the objects). Once an object has been created the identifier and the type never change, while its value can either change (mutable objects) or stay constant (immutable objects).

Python provides the following built-in data types:

We will stick with the simplest ones for now, but later on we will dive deeper into all of them.

Variables¶

Variables are just references to objects, in other words they are the name given to an object. Variables can be assigned to objects by using the assignment operator =.

The instruction

[6]:

sides = 4

might represent the number of sides of a square. What happens when we execute it in Python? An object is created, it is given an identifier, its type is set to “int” (an integer number), its value to 4 and a name sides is placed in the current namespace to point to that object, so that after that instruction we can access that object through its name. The type of an object can be accessed with the function type() and the identifier with the function id():

[7]:

sides = 4
print( type(sides) )
print( id(sides) )

<class 'int'>
140314339279184

Consider now the following code:

[8]:

sides = 4 #a square
print ("value:", sides, " type:", type(sides), " id:", id(sides))
sides = 5 #a pentagon
print ("value:", sides, " type:", type(sides), " id:", id(sides))

value: 4  type: <class 'int'>  id: 140314339279184
value: 5  type: <class 'int'>  id: 140314339279216

The value of the variable sides has been changed from 4 to 5, but as stated in the table above, the type int is immutable. Luckily, this did not prevent us to change the value of sides from 4 to 5. What happened behind the scenes when we executed the instruction sides = 5 is that a new object has been created of type int (5 is still an integer) and it has been made accessible with the same name sides, but since it is a different object (i.e. the integer 5). As a poof of this, check that the that the identifier printed above is actually different.

You can even change the type of a variable during execution but that is normally a bad idea as it makes understanding the code more complicated and leaves more room for errors.

Python allows you to do (but, please, REFRAIN FROM DOING SO!):

[9]:

sides = 4 #a square
print ("value:", sides, " type:", type(sides), " id:", id(sides))
sides = "four" #the sides in text format
print ("value:", sides, " type:", type(sides), " id:", id(sides))

value: 4  type: <class 'int'>  id: 140314339279184
value: four  type: <class 'str'>  id: 140313851926128

IMPORTANT NOTE: You can choose the name that you like for your variables (I advise to pick something reminding their meaning), but you need to adhere to some simple rules.

1. Names can only contain upper/lower case digits (A-Z, a-z), numbers (0-9) or underscores _;

2. Names cannot start with a number;

3. Names cannot be equal to reserved keywords:

Numeric types¶

We already mentioned that numbers are immutable objects. Python provides different numeric types: integers, booleans, reals (floats) and even complex numbers and fractions (but we will not get into those).

[12]:

a = 7
b = 4

print(a + b) # 11
print(a - b) # 3
print(a // b) # integer division: 1
print(a * b) # 28
print(a ** b) # power: 2401
print(a / b) # division 1.75

11
3
1
28
2401
1.75

[13]:

a = 7
b = 7
c = a/b
print("a",type(a))
print("b",type(b))
print("c",type(c))

a <class 'int'>
b <class 'int'>
c <class 'float'>

Booleans¶

These objects are used for the boolean algebra. Truth values are represented with the keywords True and False in Python. A boolean object can only have value True or False. We can convert booleans into integers with the builtin function int. Any integer can be converted into a boolean (and vice-versa) with:

[14]:

a = bool(1)
b = bool(0)
c = bool(72)
d = bool(-5)
t = int(True)
f = int(False)

print("a: ", a, " b: ", b, " c: ", c, " d: ", d , " t: ", t, " f: ", f)

a:  True  b:  False  c:  True  d:  True  t:  1  f:  0

any integer is evaluated to true, except 0. Note that, the truth values True and False respectively behave like the integers 1 and 0.

We can operate on boolean values with the boolean operators and, or, not. Recall boolean algebra for their use:

[16]:

T = True
F = False

print ("T: ", T, " F:", F)

print ("T and F: ", T and F) #False
print ("T and T: ", T and T) #True
print ("F and F: ", F and F) #False
print ("not T: ", not T) # False
print ("not F: ", not F) # True
print ("T or F: ", T or F) # True
print ("T or T: ", T or T) # True
print ("F or F: ", F or F) # False

T:  True  F: False
T and F:  False
T and T:  True
F and F:  False
not T:  False
not F:  True
T or F:  True
T or T:  True
F or F:  False

Numeric comparators are operators that return a boolean value. Here are some examples:

Example: Given a variable a = 10 and a variable b = 77, let’s swap their values (i.e. at the end a will be equal to 77 and b to 10). Let’s also check the values at the beginning and at the end.

[17]:

a = 10
b =  77
print("a: ", a, " b:", b)
print("is a equal to 10?", a == 10)
print("is b equal to 77?", b == 77)

TMP = b  #we need to store the value of b safely
b = a    #ok, the old value of b is gone... is it?
a = TMP  #a gets the old value of b... :-)

print("a: ", a, " b:", b)
print("is a equal to 10?", a == 10)
print("is a equal to 77?", a == 77)
print("is b equal to 10?", b == 10)
print("is b equal to 77?", b == 77)

a:  10  b: 77
is a equal to 10? True
is b equal to 77? True
a:  77  b: 10
is a equal to 10? False
is a equal to 77? True
is b equal to 10? True
is b equal to 77? False

[20]:

import math

R = 9.15
Pi = math.pi
Area = Pi*(R**2)
print (Area)

263.02199094017146

[26]:

import math

x = 0.000003
res = - math.sqrt(x+3)/((x+2)**3)
print(res)

-0.21650548492311453

Strings¶

Strings are immutable objects (note the actual type is str) used by python to handle text data. Strings are sequences of unicode code points that can represent characters, but also formatting information (e.g. ‘\n’ for new line). Unlike other programming languages, python does not have the data type character, which is represented as a string of length 1.

There are several ways to define a string:

[ ]:

S = "my first string, in double quotes"

S1 = 'my second string, in single quotes'

S2 = '''my third string is
in triple quotes
therefore it can span several lines'''

S3 = """my fourth string, in triple double-quotes
can also span
several lines"""

print(S, '\n') #let's add a new line at the end of the string with \n
print(S1,'\n')
print(S2, '\n')
print(S3, '\n')

To put special characters like ‘,” and so on you need to “escape them” (i.e. write them following a back-slash).

Example: Let’s print a string containing a quote and double quote (i.e. ‘ and “).

[ ]:

myString = "This is how I \'quote\' and \"double quote\" things in strings"
print(myString)

Strings can be converted to and from numbers with the functions str(), int() or float().

Example: Let’s define a string myString with the value “47001” and convert it into an int. Try adding one and print the result.

[ ]:

my_string = "47001"
print(my_string, " has type ", type(my_string))

my_int = int(my_string)

print(my_int, " has type ", type(my_int))

my_int = my_int + 1   #adds one

my_string = my_string + "1" #cannot add 1 (we need to use a string).
                          #This will append 1 at the end of the string

print(my_int)
print(my_string)

Be careful though that if the string cannot be converted into an integer, then you get an error

[ ]:

my_wrong_number = "13a"

N = int(my_wrong_number)

print(N)

Python defines some operators to work with strings. Recall the slides shown during the lecture:

Example

let’s print “Ciao” 100 times…

[1]:

my_string = "Ciao"
my_100_times_string = my_string*100
print(my_100_times_string)

CiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiaoCiao

let’s concatenate two (or more) strings

[ ]:

my_string1 = "Ciao, "
my_string2 = "How"

my_combination = my_string1 + my_string2
print(my_combination)

[2]:

my_string1 = "Ciao, "
my_string2 = "how"
my_string3 = " "
my_string4 = "are you?"

res = my_string1 + my_string2 + my_string3 + my_string4
print(res)

Ciao, How are you?

let’s create a toy example:

[3]:

my_input_string = "Hi, How are you? Do you want a beer?"

# add a new line
my_input_string = my_input_string + "\n"

# verify if the string contains "How"
print("How" in my_input_string)
# remember that it is case sensitive...
print("how" in my_input_string)

True
False

We can access strings at specific positions (indexing) or get a substring starting from a position S to a position E. The only thing to remember is that numbering starts from 0. Thei-th character of a string can be accessed as str[i-1]. Substrings can be accessed as str[S:E], optionally a third parameter can be specified to set the step (i.e. str[S:E:STEP]).

Let’s see these aspects in action with an example:

[5]:

S = "Luther College"

print(S) #print the whole string
print(S[0]) #first character
print(S[3]) #fourth character
print(S[-1]) #last character
print(S[0:6]) #first six characters
print(S[-7:]) #final seven characters
print(S[0:len(S):2]) #every other character starting from the first
print(S[1:len(S):2]) #every other character starting from the second

Luther College
L
h
e
Luther
College
Lte olg
uhrClee

Methods for the str object¶

The object str has some methods that can be applied to it (remember methods are things you can do on objects). Recall from the lecture that the main methods are:

IMPORTANT NOTE: Since Strings are immutable, every operation that changes the string actually produces a new str object having the modified string as value.

lets play with methods

upper and lower are easy

[7]:

my_string = "Trento"

print("original string\t",my_string)
print("upper string   \t",my_string.upper())

original string  Trento
upper string     TRENTO

[9]:

my_string = "TrENtO"

print("original string\t",my_string)
print("lower string   \t",my_string.lower())

original string  TrENtO
lower string     trento

as you can see, methods are applied to object!!!

object .method(parameters)

in our case… sting.method()

methods like upper and lower do not take any parameter!

Others like strip or find take also parameters…

let’s see this in practice

[13]:

my_string = ">Hi how are you?>"

my_modified_sting = my_string.strip(">")
print(my_modified_sting)

Hi how are you?

we can do it only to the left lstrip or to the right rstrip

[17]:

my_string = "><> This is TRENTO! das"

fixed_left = my_string.lstrip("><>")
fixed = fixed_left.rstrip(" das")

print(fixed)

 This is TRENTO!

The replace method is really intuitive…

[18]:

text = "My name is Pablo"

new_text = text.replace("Pablo","Antonio")

print(new_text)

My name is Antonio

startwith endswith

[21]:

text = "This is Trento"

# startwith
print(text.startswith("Thi"))
print(text.startswith("This"))
print(text.startswith("Thiss"))
print("\n")
# endwith
print(text.endswith("nto"))
print(text.endswith("rento"))
print(text.endswith("rrento"))

True
True
False


True
True
False

find

[24]:

text = "We are learning python3, we are also bla bla bla"

print(text.find("are")) # the first occorence
print(text.find("We"))
print(text.find("WE")) # not present

3
0
-1

rfind

[28]:

text = "We are learning python3, we are also bla bla bla"

print(text.rfind("are"))

28

[31]:

# is it true?
print(text[28:28+len("are")])

are

yes it worked :)

count just counts

[36]:

text = "Tfasjskdlftrentojasdjfkasjdjskdlfjasdlfjasdjfasdjaklsfaskljkljfdasaklantonioflasdfjklajdfwiojasflkfjasdllucakfjdiosjtalkjcjsadlfjlasd"

print(text.count("f"))
print(text.count("t"))
print(text.count("sk"))

15
4
3

Exercises¶

1. Given the following string on two lines:

text = """Nobody said it was easy
No one ever said it would be this hard"""

write some python code that

1. prints the whole string; b)prints the first and last character; c) prints the first 10 characters; d) prints from the 19th character to the e) pints the string all in capital letters.

[34]:

text = """Nobody said it was easy
No one ever said it would be this hard"""
# a) prints the whole text
print(text)


#some empty space...
print("")

# b) 1st and last character
print("1st char: ", text[0], " last char: ", text[-1])

#c) the 1st 10 characters:
print("1st 10 chars:", text[0:10])

#d) from the 19th to the 31st char
print("\nCharacters from 19 to 31:")
print(text[18:31])
print("\nAll upper case:")
upper_text = text.upper()
print(upper_text) #equivalent to: print(text.upper())
print("")
#NOTE THAT:
print(text)
print("")
#is different from
print(upper_text)
print("")
#as confirmed by python:
print("text and upper_text are equal: ", text == upper_text)

print("")
print("Newline? ", "\n" in text)

Nobody said it was easy
No one ever said it would be this hard

1st char:  N  last char:  d
1st 10 chars: Nobody sai

Characters from 19 to 31:
 easy
No one

All upper case:
NOBODY SAID IT WAS EASY
NO ONE EVER SAID IT WOULD BE THIS HARD

Nobody said it was easy
No one ever said it would be this hard

NOBODY SAID IT WAS EASY
NO ONE EVER SAID IT WOULD BE THIS HARD

text and upper_text are equal:  False

Newline?  True

2. given the input string S = “a 1 b 2 c 3”, replace each digit(1,2,3) with “DIGIT” and each character with “CHARACTER

[35]:

stringa = "a 1 b 2 c 3"

digit = "DIGIT"
character = "CHARACTER"

risultato = stringa.replace("1", digit)
risultato = risultato.replace("2", digit)
risultato = risultato.replace("3", digit)
risultato = risultato.replace("a", character)
risultato = risultato.replace("b", character)
risultato = risultato.replace("c", character)

print(risultato)

CHARACTER DIGIT CHARACTER DIGIT CHARACTER DIGIT

3. Compute 1/7 in Python, you ll get a float, store the result in a variable, verify if:

a)It contains the number 9 b)The first six decimal are equal to the next six.

Hint: convert the float into string

[32]:

valore = 1.0 / 7.0
print(valore)                        # 0.14285714285714285

valore_come_stringa = str(valore)
print(valore_come_stringa)           # "0.14285714285714285"

print("9" in valore_come_stringa)    # False

indice_punto = valore_come_stringa.find(".")
primi_sei_decimali = valore_come_stringa[indice_punto + 1 : indice_punto + 1 + 6]
secondi_sei_decimali = valore_come_stringa[indice_punto + 1 + 6 : indice_punto + 1 + 6 + 6]
print(primi_sei_decimali == secondi_sei_decimali)    # True

0.14285714285714285
0.14285714285714285
False
True

4. You’ve got some money, so you decide to buy two models of supercars. Since you already know accidents are on the way, for each model you will buy as many cars as there are characters in each model name.

Write some code which stores in the string s the number of cars you will buy.

for instance

car1 = "Ferrari"
car2 = "Tesla"

then the result is:

I'll buy 7 Ferrari and 5 tesla

[36]:

car1, car2 = 'Jaguar','Ferrari'        # I will buy 6 Jaguar and 7 Ferrari supercars
#car1, car2 = 'Porsche','Lamborghini'  # I will buy 7 Porsche and 11 Lamborghini supercars

# write here
s = 'I will buy %s %s and %s %s supercars' % (len(car1), car1, len(car2), car2)
print(s)

I will buy 6 Jaguar and 7 Ferrari supercars

5. Given a small sequenze of biological stuff

bio_stuff = """SER A 96 77.253 20.522 75.007
VAL A 97 76.066 22.304 71.921
PRO A 98 77.731 23.371 68.681
SER A 99 80.136 26.246 68.973
GLN A 100 79.039 29.534 67.364
LYS A 101 81.787 32.022 68.157"""

we know that the first, second and third colums are not important, then we know that the 4th 5th and 6th columns represent x,y,z of something. you have to:

1. extract x,y and z of the second row and save them into variables, b) do the same for the third colum c) compute the distance. \(d((x,y,z),(x',y',z')) = \sqrt{(x-x')^2 + (y-y')^2 + (z-z')^2}\)

[1]:

structure_chain_a = """SER A 96 77.253 20.522 75.007
VAL A 97 76.066 22.304 71.921
PRO A 98 77.731 23.371 68.681
SER A 99 80.136 26.246 68.973
GLN A 100 79.039 29.534 67.364
LYS A 101 81.787 32.022 68.157"""

# let me use a shorter name :)
chain = structure_chain_a

index_first_newline = chain.find("\n")
index_second_newline = chain[index_first_newline + 1:].find("\n") + len(chain[:index_first_newline + 1])
index_third_newline = chain[index_second_newline + 1:].find("\n") + len(chain[:index_second_newline + 1])
print(index_first_newline, index_second_newline, index_third_newline)

second_row = chain[index_first_newline + 1 : index_second_newline]
print(second_row)                      # "VAL A 97 76.066 22.304 71.921"
                                         #           |    | |    | |    |
                                         #  01234567890123456789012345678
                                         #  0         1         2

x = second_row[9:15]
y = second_row[16:22]
z = second_row[23:]
print(x, y, z)
# NOTE: they are strings


third_row = chain[index_second_newline + 1 : index_third_newline]
print(third_row)                        # "PRO A 98 77.731 23.371 68.681"
                                         #           |    | |    | |    |
                                         #  01234567890123456789012345678
                                         #  0         1         2

x_prime = third_row[9:15]
y_prime = third_row[16:22]
z_prime = third_row[23:]
print(x_prime, y_prime, z_prime)
# NOTE: they are strings

# convert variables into float,
x, y, z = float(x), float(y), float(z)
x_prime, y_prime, z_prime = float(x_prime), float(y_prime), float(z_prime)

diff_x = x - x_prime
diff_y = y - y_prime
diff_z = z - z_prime

distanza = (diff_x**2 + diff_y**2 + diff_z**2)**0.5
print(distanza)

29 59 89
VAL A 97 76.066 22.304 71.921
76.066 22.304 71.921
PRO A 98 77.731 23.371 68.681
77.731 23.371 68.681
3.7958284998139775

6. Given in input

str = "14, 625, 498.002"

1. convert each comma in a dot, and print it b)convert each dot in comma, and print it c)replace each dot in comma and each comma in dot.

[40]:

str1 = "14, 625, 498.002"
print(str1)
str2 = str1.replace(",",".")
print(str2)

str3 = str1.replace(".",",")
print(str3)

str1 = str1.replace(',', 'third ')
str1 = str1.replace('.', ',')
str1 = str1.replace('third ', '.')

print(str1)

14, 625, 498.002
14. 625. 498.002
14, 625, 498,002
14. 625. 498,002

7. Calculate the zeros of the equation \(ax^2-b = 0\) where a = 10 and b = 1. Hint: use math.sqrt or ** 0.5. Finally check that substituting the obtained value of x in the equation gives zero.

[39]:

import math

A = 10
B = 1

X = math.sqrt(B/A)

print("10X**2 - 1 = 0 for X:", X)
print(10*X**2 -1 == 0)

10X**2 - 1 = 0 for X: 0.31622776601683794
True