Exam practice

A data structure is a way of holding many values so that a program can store them, find them and change them.

• List, [52, 38, 71]: values in order, which can change; marks to average, a queue.
• String, "Bhaktapur": a sequence of characters that can’t change; text, a message.
• Tuple, ("Bagmati", 13): a few values that belong together and don’t change; a date, a point.
• Dictionary, {"tea": 25}: values found by a key; prices by item, counts of words.

• i."white"
• ii."yellow" (the last)
• iii.["white", "red"] (positions 1 and 2)
• iv.["blue", "white"]
• v.3 (the slice is ["red", "green", "yellow"])
• vi.2

[4, 5, 1] 9

After append(9): [4, 7, 1, 9]. After insert(1, 5): [4, 5, 7, 1, 9]. pop() takes out the last, 9, into x: [4, 5, 7, 1]. remove(7): [4, 5, 1].

A list keeps values in order and finds them by their position, a number from 0. A dictionary keeps key–value pairs and finds a value by its key, a name you choose; a key comes only once.
The same marks: as a list, marks = [72, 58, 90], where marks[1] is 58 but nothing says whose it is; as a dictionary, marks = {"Aarati": 72, "Bikash": 58, "Chhiring": 90}, where marks["Bikash"] is 58.
To find a student’s marks by name, the dictionary is better: one step, and the name is kept with the marks. To work out the class average, or to sort the marks, a list is enough, since every value is used in turn and names don’t matter.

sentence = input("A sentence: ")words = sentence.split()print(len(words), "words")longest = ""for w in words:    if len(w) > len(longest):        longest = wprint("Longest:", longest)print(" ".join(words[::-1]))

A sentence: we climbed to the top of Nagarkot7 wordsLongest: NagarkotNagarkot of top the to climbed we

split() gives the list of words; the highest-so-far pattern compares their lengths; words[::-1] is the list reversed, and join() glues it back together with spaces.

word = input("A word: ")counts = {}for ch in word.lower():    counts[ch] = counts.get(ch, 0) + 1print(counts)

A word: banana{'b': 1, 'a': 3, 'n': 2}

A for loop over a string gives its characters. Each is a key in the tally; get(ch, 0) gives its count so far, or 0 for a new letter.

It prints [52, 38, 71]. Each time round, m holds a copy of the item’s value; m = m + 5 changes m only, not the item in the list.
Way 1, change each item through its position:

marks = [52, 38, 71]for i in range(len(marks)):    marks[i] = marks[i] + 5print(marks)

Way 2, build a new list and put it in the variable:

marks = [52, 38, 71]new = []for m in marks:    new.append(m + 5)marks = newprint(marks)

Both print [57, 43, 76].

text = """Pokhara,1200Chitwan,900Butwal,1100Dhulikhel,150"""fares = {}for line in text.splitlines():    town, fare = line.split(",")    fares[town] = int(fare)print("Pokhara:", fares["Pokhara"])cheapest = min(fares, key=fares.get)print("Cheapest:", cheapest, fares[cheapest])

Pokhara: 1200Cheapest: Dhulikhel 150

Each line is split into a list of two strings, unpacked into town and fare. A dictionary fits, because fares are looked up by town. Instead of min(fares, key=fares.get), the lowest-so-far pattern over fares.items() works too.

Inside the loops over r and c, two more, for dr in [-1, 0, 1]: and for dc in [-1, 0, 1]:, reach the square around it. Add up and count only pixels on the photo.

from nyatapola import photofrom pixels import show_grid blurred = []for r in range(len(photo)):    row = []    for c in range(len(photo[0])):        total = 0        count = 0        for dr in [-1, 0, 1]:            for dc in [-1, 0, 1]:                if 0 <= r + dr < len(photo) and 0 <= c + dc < len(photo[0]):                    total = total + photo[r + dr][c + dc]                    count = count + 1        row.append(total // count)    blurred.append(row)show_grid(blurred)

Picture

Each new pixel mixes its gray with its neighbors’, so where a dark roof meets the pale sky the jump from dark to light is spread over three pixels instead of one. The test on line 12 matters: on the top row r + dr is −1, and photo[-1] would quietly read the bottom row, with no error.

Data: a dictionary, key the item’s name, value how many are left: each sale looks up one item by its name, and changes its count.

IF item is not in stock OR stock of item = 0 THEN    RETURN FalseELSE    SET stock of item TO stock of item − 1    RETURN TrueEND IF

def sell(stock, item):    """Take one item off the stock. Return True if it was sold."""    if item not in stock or stock[item] == 0:        return False    stock[item] = stock[item] - 1    return True stock = {"copy": 2, "pen": 0}print(sell(stock, "copy"), sell(stock, "pen"), sell(stock, "ruler"))print(stock)

True False False{'copy': 1, 'pen': 0}

The function changes the dictionary it is given (the shop’s real stock), so the caller sees the new counts, and it returns True or False to say whether the sale happened. item not in stock is checked first, so stock[item] is never looked up for a missing key (or doesn’t look at its right side when the left is already True).