0%

Antwoorden uit je notities · oefening

Splits de notities in fragmenten

Om het juiste deel van een notitie op te halen, heeft een programma de notities eerst in delen nodig. Deze les splitst elke notitie in alinea’s en nummert ze, zodat elke passage een korte naam heeft, zoals 03-lists#4: de vierde alinea van de lijstennotitie.

Tekst splitsen op een scheidingsteken

text.split(separator) knipt een string op elke plek waar separator voorkomt en geeft de stukken daartussen terug als lijst. De scheidingstekens zelf vallen weg:

line = "ids,03-lists,06-dictionaries"
print(line.split(","))
print("one\n\ntwo\n\n\n\nthree".split("\n\n"))
print("# Title\n\nA first paragraph.\n".split("\n\n"))

Kijk goed naar de tweede regel. Vier regeleinden achter elkaar bevatten twee scheidingstekens, dus zit er een leeg stuk tussen. En bij de derde regel blijft het regeleinde aan het eind van de tekst in het laatste stuk staan. Om die twee redenen strippen de stappen hieronder elk stuk en slaan ze lege stukken over. In Markdown scheidt een lege regel alinea’s, en een lege regel is twee regeleinden achter elkaar, "\n\n".

Les 3 gebruikt split() zonder argument; dat splitst op elke reeks spaties en regeleinden.

Wat een fragment is

Elke notitie in notes/ is Markdown: een titelregel die met # begint, daarna alinea’s die door lege regels gescheiden zijn. Een codeblok in een notitie bevat geen lege regel, dus het blijft één stuk. Een fragment (chunk) is één alinea, opgeslagen als dictionary:

{"note_id": "03-lists", "number": 4, "text": "Because a list is changed in place, ..."}

De titel is geen fragment. Die noemt het onderwerp maar beantwoordt niets, dus als bron zou hij alleen de plaats innemen van een alinea die dat wel doet.

Bouw split_note

split_note(note_id, text) geeft de fragmenten van één notitie terug:

  1. Splits text op "\n\n".

  2. Haal bij elk stuk met .strip() de spaties en regeleinden aan beide kanten weg.

  3. Sla een stuk over dat leeg is of met # begint. Eerst strippen, dan controleren, zodat een titel die na een extra regeleinde kwam toch herkend wordt.

  4. Nummer de stukken die je houdt vanaf 1. Gebruik een teller die bij 0 begint en voor elk gehouden stuk met 1 omhooggaat, zodat een overgeslagen titel geen nummer verbruikt.

  5. Voeg {"note_id": note_id, "number": number, "text": piece} toe aan een lijst en geef de lijst terug.

Een notitie die alleen haar titel bevat, geeft een lege lijst.

Bouw note_chunks

note_chunks(notes) neemt de dictionary van load_notes en geeft de fragmenten van elke notitie terug in één platte lijst: alle fragmenten van de eerste notitie, dan alle fragmenten van de tweede, enzovoort, in de volgorde van de dictionary. Loop over de notitie-ids, roep voor elk ervan split_note aan en voeg elk fragment dat die teruggeeft toe aan één lijst. Als je de lijst die split_note teruggeeft als één item toevoegt, krijg je in plaats daarvan een lijst van lijsten. Verander notes niet.

Voer het uit

Voer python retrieval.py uit. De demonstratie splitst elke notitie, drukt af hoeveel fragmenten er zijn en drukt de fragmenten van de lijstennotitie af:

The notes split into 76 chunks. The chunks of 03-lists:
{'note_id': '03-lists', 'number': 1, 'text': 'A list is an ordered collection of values. You write one with square brackets, such as `scores = [90, 72, 85]`. A list can hold values of any type, including a mix of types and other lists.'}
{'note_id': '03-lists', 'number': 2, 'text': 'Each item has a position, called its index, starting at 0. `scores[0]` is the first item and `scores[-1]` is the last. Reading an index that does not exist raises `IndexError`. A slice such as `scores[0:2]` returns a new list with the items from position 0 up to, but not including, position 2.'}
{'note_id': '03-lists', 'number': 3, 'text': 'Lists are mutable, so you can change them after creating them. `scores.append(60)` adds an item to the end, `scores.insert(0, 100)` adds one at a position, `scores.remove(72)` removes the first matching value, and `scores[1] = 75` replaces an item in place. These methods change the list and return `None`, so `scores = scores.append(60)` loses the list.'}
{'note_id': '03-lists', 'number': 4, 'text': 'Because a list is changed in place, two names that refer to the same list both see every change. Use `scores.copy()` or `list(scores)` when you need an independent list. Adding two lists with `+` also builds a new list and leaves both originals unchanged.'}
{'note_id': '03-lists', 'number': 5, 'text': '`len(scores)` tells you how many items a list holds, and `value in scores` tells you whether a value is one of them.'}
Run stopped at the next function to build: words is built in Lesson 3.

De twaalf notities leveren 76 fragmenten op, tussen 4 en 8 per notitie. Het vierde fragment van de lijstennotitie is het fragment dat antwoord geeft op “How do I make an independent copy of a list?”. De volgende les geeft het programma een manier om het te vinden.

Wat geeft "one\n\n\n\ntwo".split("\n\n") terug?

Een notitie bestaat uit een titel en daarna drie alinea's. Welke nummers krijgen haar fragmenten?

Opdracht

Vervang in retrieval.py de onafgemaakte bodies van twee functies.

  • split_note(note_id, text): splits text op "\n\n". Strip elk stuk en sla stukken over die leeg zijn of met # beginnen. Nummer de gehouden stukken vanaf 1 met een teller en geef een lijst fragmentdictionaries {"note_id": note_id, "number": number, "text": piece} terug, in de volgorde waarin de stukken voorkomen.

  • note_chunks(notes): geef één platte lijst terug met de fragmenten van elke notitie in de dictionary notes, notitie voor notitie in de volgorde van de dictionary. Gebruik split_note voor elke notitie en verander notes niet.

Voer python retrieval.py uit om te zien hoeveel fragmenten de notities opleveren, en controleer daarna je werk.