This lab provides practice on expressions, lists, dictionaries, control flow statements and functions.
Instructions:
Modify this notebook by adding the Python code described below.
Test your code using the menu item Cell ► Run All
Save the notebook (the .ipynb file) and upload it to the appropriate Assignment folder on the course web site.
Write a function, substrings(s)
that returns a list containing all possible initial substrings from s
in increasing length. For example if s
is "abc123"
then substrings(s)
should return ['a', 'ab', 'abc', 'abc1', 'abc12', 'abc123']
.
def substrings(s):
l=[]
for i in range(1,len(s)+1):
l.append(s[0:i])
return l
def substrings(s):
return [s[:n+1] for n in range(len(s))]
substrings("abc123")
['a', 'ab', 'abc', 'abc1', 'abc12', 'abc123']
Write a function, reverseif(l,p)
, where l
is a list of str
ings and a p
is a list of bool
eans. The function should return a list whose i'th element is:
l[i]
if p[i]
is False
, orl[i]
with the order of the characters reversed if p[i]
is True
. For example, reverseif(['abc', '123', 'xyzzy', 'zebra'], [True, False, False, True])
should return ['cba', '123', 'xyzzy', 'arbez']
.
def reverseif(l,p):
r = []
for i,s in enumerate(l):
if p[i]:
r.append(s[::-1])
else:
r.append(s)
return r
def reverseif(l,p):
return [s[::-1] if r else s for s,r in zip(l,p)]
reverseif(['abc', '123', 'xyzzy', 'zebra'], [True, False, False, True])
['cba', '123', 'xyzzy', 'arbez']
Write a function, removechars(s,x)
, that returns a set
of the characters in the string s
that are not in the string x
.
For example, removechars('giraffe',"aeiou")
should return {'g', 'r', 'f'}
(with the items in any order).
def removechars(s,x):
return set(s)-set(x)
removechars('giraffe',"aeiou")
{'f', 'g', 'r'}
Write a function sumvalues(d)
that returns a dictionary whose items have the keys in the dictionary d
and whose values are the sums of the iterable values in d
. For example, if d
is {32:(1,2,3), 'xyz':{4,5,6}, (1,2):[5,9,10,11]}
then sumvalues(d)
should return {32:6, 'xyz':15, (1,2):35}
.
def sumvalues(d):
r = {}
for k,v in d.items():
for i,s in enumerate(v):
rv = s if not i else rv+s
r[k]=rv
return r
def sumvalues(d):
return {k:sum(v) for k,v in d.items()}
d={32:(1,2,3), 'xyz':{4,5,6}, (1,2):[5,9,10,11]}
sumvalues(d)
{32: 6, 'xyz': 15, (1, 2): 35}
Write a function toggletype(x)
that toggles the type of x
and each item in x
. For this question toggle means to change the type of the object from list to tupple or vice-versa. For example, toggletype(([1,2,3],('ab','c'),("hello",)))
would return [(1,2,3),['a','b'],["hello"]]
and toggletype([(1,2,3),['ab','c'],["hello"]])
would return ([1, 2, 3], ('ab', 'c'), ('hello',))
.
def toggletype(x):
l=[]
for i in x:
if type(i) == list:
l.append(tuple(i))
else:
l.append(list(i))
return l if type(x) == tuple else tuple(l)
toggletype(([1,2,3],('ab','c'),("hello",)))
[(1, 2, 3), ['ab', 'c'], ['hello']]
# lab validation code; do not modify
def labcheck():
import copy, random, re, string, types
from random import randint
def checkre(pat,ok,nok):
for s in ok:
assert re.fullmatch(pat,s), \
f"pattern '{pat}'\n did not match string '{s}'"
for s in nok:
assert not re.fullmatch(pat,s), \
f"pattern '{pat}'\n matched string '{s}'"
def randwords(n,chars=string.ascii_lowercase,nl=(2,5)):
l = set()
while len(l)<n:
l |= set((''.join([chars[randint(0,len(chars)-1)] for i in range(randint(*nl))]),))
return list(l)
def q1():
s=randwords(1,nl=(5,8))[0]
os=copy.deepcopy(s)
l=substrings(s)
assert(len(l) == len(os)), f"substrings({os}) returns {l}"
cl=[l[i][i] for i in range(len(l))]
assert os == ''.join(cl), f"substrings({os}) returns {l}"
def q2():
l = randwords(randint(5,8),nl=(2,5))
p = [randint(0,1) for s in l]
ol, op = copy.deepcopy(l), copy.deepcopy(p)
assert all([s == ''.join(reversed(ol[i])) if op[i] else ol[i] for i,s in enumerate(reverseif(l,p))]), \
f"reverserif({ol},{op}) returns {l}"
def q3():
s = randwords(1,nl=(10,15))[0]
x = randwords(1,nl=(10,15))[0]
os = copy.deepcopy(s)
ox = copy.deepcopy(x)
r = removechars(s,x)
assert all([(l in x and (l not in r)) or (l not in x and (l in r)) for l in os]), \
f"removechars({os},{ox}) returns {r}"
def q4():
k=randwords(randint(2,4))+[randint(1,999) for i in range(randint(2,4))]
random.shuffle(k)
v=[[randint(-1,9) for i in range(randint(2,4))] for i in range(len(k))]
v=[set(x) if randint(0,1) else x for x in v]
d=dict(zip(k,v))
od=copy.deepcopy(d)
r = sumvalues(d)
assert len(r) == len(od) and all([v == sum(od[k]) for k,v in r.items()]), \
f"sumvalues({od}) returns {r}"
def q5():
l=[randwords(randint(2,3)) for l in range(randint(3,6))]
l=[tuple(x) if randint(0,1) else x for x in l]
l=tuple(l) if randint(0,1) else l
ol=copy.deepcopy(l)
l=toggletype(l)
assert len(l) == len(ol) and \
not ({list,tuple} ^ {type(l),type(ol)}) and \
all([not ({list,tuple} ^ {type(x),type(ol[i])}) for
i,x in enumerate(l)]), f"toggletype({ol}) returns {l}"
for s,i in [(s,s[1:]) for s in locals().keys() if re.search(r'q\d+',s)]:
try:
locals()[s]()
print(f"Question {i} OK.")
except Exception as e:
print(f"Failed check for Question {i}: {e}")
labcheck()
Question 1 OK. Question 2 OK. Question 3 OK. Question 4 OK. Question 5 OK.