Differences
This shows you the differences between two versions of the page.
| Both sides previous revision Previous revision Next revision | Previous revision | ||
|
lfa:lab01-python-intro [2021/09/08 11:04] pdmatei |
lfa:lab01-python-intro [2021/10/07 11:32] (current) ioana.georgescu [List comprehensions] |
||
|---|---|---|---|
| Line 12: | Line 12: | ||
| ==== List traversal ==== | ==== List traversal ==== | ||
| - | **1.1.** Write a function ''f(l)'' which determines the maximum of a list ''l'' of integers. | + | **Exercise 1.1.** Write a function ''f(l)'' which determines the maximum of a list ''l'' of integers. |
| <hidden The pythonic way> | <hidden The pythonic way> | ||
| Line 23: | Line 23: | ||
| </hidden> | </hidden> | ||
| - | **1.2.** Modify the previous function to ''f(l,start,stop)'' and determine the maximum between positions ''start'' and ''stop''. | + | **Exercise 1.2.** Modify the previous function to ''f(l,start,stop)'' and determine the maximum between positions ''start'' and ''stop''. |
| <hidden The pythonic way> | <hidden The pythonic way> | ||
| Line 35: | Line 35: | ||
| ==== Slicing lists ==== | ==== Slicing lists ==== | ||
| - | **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]''. | + | **Exercise 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]''. |
| <hidden The pythonic way> | <hidden The pythonic way> | ||
| Line 45: | Line 45: | ||
| l[:x] | l[:x] | ||
| # the last element of a list: | # the last element of a list: | ||
| - | l[:-1] | + | l[-1] |
| # the last three elements of a list: | # the last three elements of a list: | ||
| - | l[:-3] | + | l[-3:] |
| # the slice from n-3 to n-1, where n is the number of elements from the list | # the slice from n-3 to n-1, where n is the number of elements from the list | ||
| l[-3:-1] | l[-3:-1] | ||
| Line 53: | Line 53: | ||
| </hidden> | </hidden> | ||
| - | **1.4.** Write a pythonic function to check if a list is palindrome. | + | **Exercise 1.4.** Write a pythonic function to check if a list is palindrome. |
| ===== Other datatypes ===== | ===== Other datatypes ===== | ||
| Line 69: | Line 69: | ||
| </code> | </code> | ||
| - | **1.5.** Write a function which determines (and returns) the **longest** sequence of consecutive integers from a list. | + | **Exercise 1.5.** Write a function which determines (and returns) the **longest** sequence of consecutive integers from a list. |
| ==== Dictionaries ==== | ==== Dictionaries ==== | ||
| Line 87: | Line 87: | ||
| </code> | </code> | ||
| - | **1.6.** Write a function which determines the number of occurrences of each character in a string. | + | **Exercise 1.6.** Write a function which determines the number of occurrences of each character in a string. |
| <hidden The pythonic way> | <hidden The pythonic way> | ||
| <code python> | <code python> | ||
| Line 115: | Line 115: | ||
| </code> | </code> | ||
| - | **1.7.** Determine the list of characters which occur in a string. E.g. for "limbajeformale" we have: "limbajefor". (Hint 1: in Python there is no difference between a character and a singleton string and strings are just lists; Hint 2: to create a list from another object, use ''list()''). | + | **Exercise 1.7.** Determine the list of characters which occur in a string. E.g. for "limbajeformale" we have: "limbajefor". (Hint 1: in Python there is no difference between a character and a singleton string and strings are just lists; Hint 2: to create a list from another object, use ''list()''). |
| ==== Pairs ==== | ==== Pairs ==== | ||
| Line 140: | Line 140: | ||
| from functools import reduce | from functools import reduce | ||
| + | # adds 1 to each element of a list | ||
| def allplus1(l): | def allplus1(l): | ||
| return map(lambda x:x+1,l) | return map(lambda x:x+1,l) | ||
| - | def sum (l): | + | # computes the sum of elements of a list |
| + | def sum_l (l): | ||
| # inner functions are very useful for defining local, reusable functionality | # inner functions are very useful for defining local, reusable functionality | ||
| def plus(x,y): | def plus(x,y): | ||
| Line 155: | Line 157: | ||
| ==== List comprehensions ==== | ==== List comprehensions ==== | ||
| + | List comprehensions are widely used programming tools in Python. Usage examples: | ||
| + | <code python> | ||
| + | # adding 1 to each element of a list | ||
| + | l1 = [x+1 for x in [1,2,3]] | ||
| + | # [2,3,4] | ||
| + | # packing elements into pairs | ||
| + | l2 = [(x,x+1) for x in [1,2,3]] | ||
| + | # [(1,2), (2,3), (3,4)] | ||
| - | Inner functions | + | # unpacking pairs in the for notation |
| - | List comprehensions, filters | + | l3 = [x+y for (x,y) in [(1,2), (2,3), (3,4)]] |
| - | Classes and inheritance, instance-of | + | # [3,5,7] |
| - | toString | + | |
| - | Higher-order functions and lambdas | + | |
| - | Unpacking (for tuples, lists) | + | |
| + | # combined list comprehensions | ||
| + | l4 = [(x,y) for x in [1,2,3] for y in [4,5,6]] | ||
| + | # [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)] | ||
| - | <hidden The Pythonic way> This text will be hidden <code python> solution </code> </hidden> | + | # filters |
| + | l5 = [x for x in [1,2,3,4] if x>2] | ||
| + | # [3,4] | ||
| + | </code> | ||
| + | **Exercise 1.8.** Write a function which takes a list of records //first name, last name, CNP// (encoded as tuples), and returns a list of **the last names** and **ages** of all females which are younger than the average of the entire list. E.g. ''[ ("Mary", "Smith", "2030602123456"), ("Anne", "Doe", "2121092123456"), ("Matei", "Dan", "1121202123456"), ("Maggie", "Byrne", "2121078123456")]'' yields ''[("Smith",19), ("Doe",29)]''. Maggie was born in '78, whereas Mary, Anne and Matei were born in '94, '92 and 2002, respectively. | ||
| - | + | <hidden The pythonic way> | |
| - | **Exercise 6** Write a function which searches for a list of patterns in a text. | + | |
| <code python> | <code python> | ||
| - | def find_patterns (pattern_list, text): | + | from functools import reduce |
| - | # checks if pattern is found at position index in text | + | |
| - | def inner_search (pattern,index): | + | |
| - | </code> | + | |
| - | Remark: | + | def getYouth(l): |
| - | * Python supports functional-style programming to some extent. | + | # this function computes the age of a given CNP |
| - | <code python> | + | def age(cnp): |
| - | def plus1(x): | + | # conversion to integer of the two-character year code |
| - | return x + 1 | + | if int(cnp[5:8]) <= 21: |
| + | return 2021 - int("20"+cnp[5:7]) | ||
| + | else: | ||
| + | return 2021 - int("19"+cnp[5:7]) | ||
| | | ||
| - | print(map(plus1,[1,2,3])) | + | # computing the average ages (a map could have also been used) |
| - | print(map(lambda x:x+1, [1,2,3])) | + | avg = reduce(lambda a,b:a+b, [age(x[-1]) for x in l]) / len(l) |
| + | |||
| + | # we return the last name and the age of the filtered list l | ||
| + | return [(ln,age(cnp)) for (fn,ln,cnp) in l if cnp[0]=='2' and age(cnp) <= avg] | ||
| </code> | </code> | ||
| + | </hidden> | ||
| + | |||
| + | |||
| + | |||
| - | **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'': | ||
| - | <code python> | ||
| - | def plus1(x): | ||
| - | return x + 1 | ||
| - | | ||
| - | print([plus1(x) for x in [1,2,3]]) | ||
| - | print([(x + 1) for x in [1,2,3]])) | ||
| - | </code> | ||
| - | List comprehensions also support the functionality of ''filter'': | ||
| - | <code python> | ||
| - | print([(x+1) for x in [1,2,3,4,5,6] if (x % 2 == 0)]) | ||
| - | </code> | ||
| - | **Exercise 9** Modify the previous implementation and instead of ''for'', use list comprehensions. | + | /* |
| ==== Classes and inheritance ==== | ==== Classes and inheritance ==== | ||
| Line 272: | Line 279: | ||
| * Extend the class example shown previously to include class ''Node'' which models non-empty trees. Implement methods ''size'' and ''contains''. | * Extend the class example shown previously to include class ''Node'' which models non-empty trees. Implement methods ''size'' and ''contains''. | ||
| + | |||
| + | */ | ||
| + | |||
| + | ===== Practice ===== | ||
| + | |||
| + | A labelled graph is encoded as a file where: | ||
| + | * **the first line** consists of the number of nodes | ||
| + | * **each subsequent line** is an edge ''<from> <label> <to>'' | ||
| + | Example: | ||
| + | <code> | ||
| + | 5 | ||
| + | 0 X 1 | ||
| + | 1 O 2 | ||
| + | 1 X 3 | ||
| + | 1 O 4 | ||
| + | 4 X 1 | ||
| + | 3 O 2 | ||
| + | </code> | ||
| + | |||
| + | * Suppose we encode streets as labelled graphs, where each label 'X' or 'O' denotes if a street is closed or open. | ||
| + | * Compute the set of accessible nodes from a given **source**, via open streets. | ||
| + | * (Hint1: google //Python read lines// to see how to read from a file; also, google ''split'' in Python) | ||
| + | * (Hint2: you will need a dictionary to store, for each node and label l, the list of its l-successors) | ||
| + | |||
| + | |||
| + | ===== Haskell practice ===== | ||
| + | |||
| + | Solve the same exercise, only build your own input as a string, instead of a file. | ||