0%

Antworten aus deinen Notizen · Übung

Die Notizen in Abschnitte aufteilen

Um den richtigen Teil einer Notiz abzurufen, braucht ein Programm die Notizen zuerst in Teilen. Diese Lektion zerlegt jede Notiz in Absätze und nummeriert sie, sodass jede Passage einen kurzen Namen hat, etwa 03-lists#4: der vierte Absatz der Notiz über Listen.

Text an einem Trennzeichen aufteilen

text.split(separator) schneidet einen String an jedem Vorkommen von separator auf und gibt die Stücke dazwischen als Liste zurück. Die Trennzeichen selbst fallen 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"))

Schau dir die zweite Zeile genau an. Vier Zeilenumbrüche hintereinander enthalten zwei Trennzeichen, also liegt dazwischen ein leeres Stück. Und die dritte Zeile behält den Zeilenumbruch am Ende des Textes in ihrem letzten Stück. Aus diesen beiden Gründen entfernen die Schritte unten bei jedem Stück die Leerzeichen und Zeilenumbrüche an den Rändern und überspringen die leeren Stücke. In Markdown trennt eine Leerzeile Absätze, und eine Leerzeile sind zwei Zeilenumbrüche hintereinander, "\n\n".

Lektion 3 verwendet split() ohne Argument. Das teilt an jeder Folge von Leerzeichen und Zeilenumbrüchen.

Was ein Abschnitt ist

Jede Notiz in notes/ ist Markdown: eine Titelzeile, die mit # beginnt, dann Absätze, die durch Leerzeilen getrennt sind. Ein Codeblock in einer Notiz enthält keine Leerzeile, also bleibt er an einem Stück. Ein Abschnitt ist ein Absatz, gespeichert als Dictionary:

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

Der Titel ist kein Abschnitt. Er nennt das Thema, beantwortet aber nichts. Als Quelle würde er nur den Platz eines Absatzes einnehmen, der etwas beantwortet.

Baue split_note

split_note(note_id, text) gibt die Abschnitte einer Notiz zurück:

  1. Teile text an "\n\n" auf.

  2. Entferne bei jedem Stück mit .strip() die Leerzeichen und Zeilenumbrüche an beiden Enden.

  3. Überspringe ein Stück, das leer ist oder mit # beginnt. Erst bereinigen, dann prüfen, damit ein Titel nach einem zusätzlichen Zeilenumbruch trotzdem erkannt wird.

  4. Nummeriere die behaltenen Stücke ab 1. Verwende einen Zähler, der bei 0 beginnt und für jedes behaltene Stück um 1 steigt, damit ein übersprungener Titel keine Nummer verbraucht.

  5. Hänge {"note_id": note_id, "number": number, "text": piece} an eine Liste an und gib die Liste zurück.

Eine Notiz, die nur ihren Titel enthält, ergibt eine leere Liste.

Baue note_chunks

note_chunks(notes) nimmt das Dictionary aus load_notes und gibt die Abschnitte aller Notizen in einer flachen Liste zurück: alle Abschnitte der ersten Notiz, dann alle Abschnitte der zweiten und so weiter, in der Reihenfolge des Dictionarys. Gehe in einer Schleife über die Notiz-IDs, rufe für jede split_note auf und hänge jeden zurückgegebenen Abschnitt an eine gemeinsame Liste an. Würdest du die Liste, die split_note zurückgibt, als ein einzelnes Element anhängen, bekämst du stattdessen eine Liste von Listen. Verändere notes nicht.

Ausführen

Führe python retrieval.py aus. Die Demonstration teilt jede Notiz auf, gibt aus, wie viele Abschnitte es gibt, und gibt die Abschnitte der Notiz über Listen aus:

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.

Die zwölf Notizen ergeben 76 Abschnitte, zwischen 4 und 8 pro Notiz. Der vierte Abschnitt der Notiz über Listen ist derjenige, der „How do I make an independent copy of a list?“ beantwortet. Die nächste Lektion gibt dem Programm eine Möglichkeit, ihn zu finden.

Was gibt "one\n\n\n\ntwo".split("\n\n") zurück?

Eine Notiz besteht aus einem Titel und drei Absätzen. Welche Nummern bekommen ihre Abschnitte?

Aufgabe

Ersetze in retrieval.py die unfertigen Rümpfe von zwei Funktionen.

  • split_note(note_id, text): Teile text an "\n\n" auf. Bereinige jedes Stück mit strip und überspringe Stücke, die leer sind oder mit # beginnen. Nummeriere die behaltenen Stücke mit einem Zähler ab 1 und gib eine Liste von Abschnitts-Dictionarys {"note_id": note_id, "number": number, "text": piece} zurück, in der Reihenfolge, in der die Stücke vorkommen.

  • note_chunks(notes): Gib eine flache Liste mit den Abschnitten aller Notizen im Dictionary notes zurück, Notiz für Notiz in der Reihenfolge des Dictionarys. Verwende split_note für jede Notiz und verändere notes nicht.

Führe python retrieval.py aus, um zu sehen, wie viele Abschnitte die Notizen ergeben, und prüfe dann deine Arbeit.