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/14 09:38] pdmatei |
lfa:lab01-python-intro [2021/10/07 11:32] (current) ioana.georgescu [List comprehensions] |
||
|---|---|---|---|
| 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 188: | Line 188: | ||
| def getYouth(l): | def getYouth(l): | ||
| - | def age(entry): | + | # this function computes the age of a given CNP |
| - | if int(entry[5:8]) <= 21: | + | def age(cnp): |
| - | return 2021 - int("20"+entry[5:8]) | + | # conversion to integer of the two-character year code |
| - | else | + | if int(cnp[5:8]) <= 21: |
| - | return 2021 - int("19"+entry[5:8]) | + | return 2021 - int("20"+cnp[5:7]) |
| - | + | else: | |
| - | avg = reduce(lambda a,b:a+b, map(age,l)) / len(l) | + | return 2021 - int("19"+cnp[5:7]) |
| - | [(ln,age(cnp)) for (fn,ln,cnp) in l if cnp[0]=='2'] | + | |
| + | # computing the average ages (a map could have also been used) | ||
| + | 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> | </hidden> | ||
| - | Inner functions | ||
| - | List comprehensions, filters | ||
| - | Classes and inheritance, instance-of | ||
| - | toString | ||
| - | Higher-order functions and lambdas | ||
| - | Unpacking (for tuples, lists) | ||
| - | <hidden The Pythonic way> This text will be hidden <code python> solution </code> </hidden> | ||
| - | **Exercise 6** Write a function which searches for a list of patterns in a text. | ||
| - | <code python> | ||
| - | def find_patterns (pattern_list, text): | ||
| - | # checks if pattern is found at position index in text | ||
| - | def inner_search (pattern,index): | ||
| - | </code> | ||
| - | Remark: | ||
| - | * Python supports functional-style programming to some extent. | ||
| - | <code python> | ||
| - | def plus1(x): | ||
| - | return x + 1 | ||
| - | | ||
| - | print(map(plus1,[1,2,3])) | ||
| - | print(map(lambda x:x+1, [1,2,3])) | ||
| - | </code> | ||
| - | **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 314: | 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. | ||