1. Introduction to Python

Python3 is a multi-paradigm language, that combines the imperative style with the functional style. It also supports Object-Oriented programming, albeit in a limited way.

Python3 offers a few programming constructs that:

• make life real easy for the programmer,
• yield efficient programs,
• sum-up to a programming style called pythonic (a blend of imperative and functional features).

This lab will introduce some of these constructs.

1.1. Write a function f(l) which determines the maximum of a list l of integers.

for elem in collection:
    # do something

1.2. Modify the previous function to f(l,start,stop) and determine the maximum between positions start and stop.

for i in range(0,len(collection)):
    # do something with collection[i]

1.3. Find the longest sequence of positive integers from a list. E.g. for the list [1,3,-1,2,0,1,5,4,-2,4,5,-3,0,1,2] the answer is [2,0,1,5,4].

# the sublist from positions 0 to x of l:
l[0:x]
# the very same list:
l[:x]
# the last element of a list:
l[:-1]
# the last three elements of a list:
l[:-3]
# the slice from n-3 to n-1, where n is the number of elements from the list
l[-3:-1]

1.4. Write a pythonic function to check if a list is palindrome.

Inner functions List comprehensions, filters Stacks Dictionaries Pairs Classes and inheritance, instance-of toString Higher-order functions and lambdas Unpacking (for tuples, lists)

 solution 

Python is an interpreted, dynamically typed language which is easy to use for scripting and prototyping applications.

C and Java programmers quickly adjust to the Python syntax. Unlike C, in Python, lists are predefined and usually more used than arrays:

# Comments begin with a '#' and end at the end of the line
l = []  # comment
l.append("1")
l.append(0)
l.append([])
 
print(l)

def func(l1, l2):
    l1.append(3)
    return l1 + l2
 
x = [1]
y = [2]
print(func(x,y))
print(x)

Remarks

• although it is possible to add type annotations, in Python a function's signature only consists of the number of parameters and their names
• objects are generally passed as reference (hence, when printing x, we see the list [1,3]) (for details see: Python data model)
• + denotes list concatenation

Exercise 1 Write a function which prints EACH repeating character from a string. (Hint: strings are lists of characters).

Dictionaries are another useful data structure. A dictionary is a <key> : <value> mapping. Unlike lists, keys may be of any type (integers, strings, or any other datatype).

d = {}
d["X"] = ["X"]
 
if "X" in d:
    print("d[X] is defined in the dictionary")
 
if not "Y" in d:
    print("d[Y] is not defined in the dictionary")

Exercise 2 Write a function returns the number of repetitions of each character from a text. (Hint: use dictionaries to store the number of repetitions.)

Exercise 3 Write a function returns the number of unique characters from a list.

Remark:

• a simpler way to ensure uniqueness is to use sets.
• a set may be created from a list: s = set([1,2,3,1])
• and in turn, a list may be created from a set: l = list(s)

Remark:

• in Python we can use arbitrarily nested functions

Exercise 6 Write a function which searches for a list of patterns in a text.

def find_patterns (pattern_list, text):
    # checks if pattern is found at position index in text
    def inner_search (pattern,index):

Remark:

• Python supports functional-style programming to some extent.

def plus1(x):
    return x + 1
 
print(map(plus1,[1,2,3]))
print(map(lambda x:x+1, [1,2,3]))

Exercise 8 Modify the previous implementation and instead of for, use map (cast the return of map to list: list(map(…)))

However, it is more common in Python to employ list comprehensions instead of map:

def plus1(x):
    return x + 1
 
print([plus1(x) for x in [1,2,3]])
print([(x + 1) for x in [1,2,3]]))

List comprehensions also support the functionality of filter:

print([(x+1) for x in [1,2,3,4,5,6] if (x % 2 == 0)])

Exercise 9 Modify the previous implementation and instead of for, use list comprehensions.

We discuss a few basics on classes and inheritance starting from the following example:

class Tree:
 
    def size(self):
        pass
    def contains(self, key):
        pass
 
class Void(Tree):
    def __init__(self):
        pass
 
    def __str__(self):
        return "Nil"
 
    def size(self):
        return 0
 
    def contains(self,key):
        return False

In the previous example, the class Tree acts as an interface. Python does not natively support interfaces, but class inheritance is supported. The instruction pass does nothing, and it helps us defer the method implementation.

The definition:

class Void(Tree)

tells us that class Void inherits Tree. Note that this contract is not binding in Python. The program will be interpreted even if Void does not correctly implement the methods in Tree.

The function

def __init__(self):

is the class constructor. We cannot explicitly define multiple constructors (but workarounds exist). Also note the mandatory presence of self, which is the Python equivalent of this. Each member class must mark as first argument self, otherwise it is not a proper member of the class, and just a nested function.

The function

def __str__(self):

is the Python equivalent for toString(). An object can be displayed using the function str

Exercise 9 Create the class Node which models non-empty trees. Implement methods size and contains.

• Write a function which prints EACH repeating character from a string. (Hint: strings are lists of characters).
• Write a function returns the number of repetitions of each character from a text. (Hint: use dictionaries to store the number of repetitions).
• Write a function returns the number of unique characters from a list. Use Python sets.
• Write a function which takes a pattern and a text and prints all indexes where an occurrence of pattern in text are found. Use Python list slicing.
• Write a function which searches for a list of patterns in a text, by extending the stub below. Whenever possible, use map instead of for.

def find_patterns (pattern_list, text):
    # checks if pattern is found at position index in text
    def inner_search (pattern,index):

• Extend the class example shown previously to include class Node which models non-empty trees. Implement methods size and contains.