Python 101 Übungsblatt 3#

Stoff:

Ergebnissicherung:

  • zuerst dieses Notebook lokal speichern

  • dann eine Kopie erzeugen und dabei die Dateinamenskonvention beachten, also z.B. s-mmuster_python-101-ln3.ipynb

  • dann die Kopie editieren!

Abgabe auf Moodle:

zusätzlich benötigte Dateien:

Überlegungen zur Didaktik: Didaktik zum Notebook Python 101 Übungsblatt 3

Datensatz laden und vorbereiten#

# psm: python_strings_methods
with open("www.w3schools.com_python_python_strings_methods.txt") as my_file:
    psm_text = my_file.read()
psm_text_zeilen = psm_text.splitlines()

assert type(psm_text_zeilen) == list

psm_text_tokens = []
for zeile in psm_text_zeilen[1:] : # die erste Zeile enthält etwas anderes, auslassen
    if len(zeile) >= 1:
        psm_text_tokens.append( zeile.split("\t" ))
#psm_text_tokens

assert len(psm_text_tokens) == 45

oder mit List Comprehension:

... # 

Ellipsis

assert len(psm_text_tokens) == 45

Liste aller Funktionsbeschreibungen#

Gegeben:

  • Unser Text in der Variablen psm_text_tokens.

Gesucht:

  • Eine Liste psm_Beschreibungen_list aller Beschreibungen

Idealerweise mit List Comprehension lösen.

psm_Beschreibungen_list = []
... # 
# die ersten 3 Elemenet angucken
psm_Beschreibungen_list[:3]

[]

assert psm_Beschreibungen_list[1] == 'Converts string into lower case'

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In [8], line 1
----> 1 assert psm_Beschreibungen_list[1] == 'Converts string into lower case'

IndexError: list index out of range

Normalisieren#

Gegeben:

  • Eine Liste psm_Beschreibungen_list aller Beschreibungen

Gesucht: Eine Liste psm_Beschreibungen_normalisiert_list von “normalisierten” Beschreibungen:

  • keine Sonderzeichen

  • nur noch Kleinbuchstaben

Sie dürfen für diese Aufgabe gerne die Funktion normalisiere aus dem Notebook Textdatei segmentieren: Aufgaben wiederverwenden:

sonderzeichen = """.,:;?!'*<>\""""
teststring = """Hä"? returns 'Nix!'"""

def normalisiere(s):
    ... # 
    ... # 
    return ergebnis
normalisiere(teststring)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In [9], line 8
      6     ... # 
      7     return ergebnis
----> 8 normalisiere(teststring)

Cell In [9], line 7, in normalisiere(s)
      5 ... # 
      6 ... # 
----> 7 return ergebnis

NameError: name 'ergebnis' is not defined

assert normalisiere(teststring) == 'hä returns nix'

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In [10], line 1
----> 1 assert normalisiere(teststring) == 'hä returns nix'

Cell In [9], line 7, in normalisiere(s)
      5 ... # 
      6 ... # 
----> 7 return ergebnis

NameError: name 'ergebnis' is not defined

psm_Beschreibungen_normalisiert_list = []

psm_Beschreibungen_normalisiert_list = \
    ... # 
#psm_Beschreibungen_normalisiert_list[:3]

assert psm_Beschreibungen_normalisiert_list[8] == 'formats specified values in a string'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In [13], line 1
----> 1 assert psm_Beschreibungen_normalisiert_list[8] == 'formats specified values in a string'

TypeError: 'ellipsis' object is not subscriptable

normalisiere() als Einzeiler#

Gegeben:

  • obige Funktion normalisiere()

gesucht:

  • Diese Funktion, in der das Ergebnis in einem “Einzeiler” berechnet wird.

def normalisiere(s):
    ... # 

assert normalisiere(teststring) == 'hä returns nix'

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
Cell In [15], line 1
----> 1 assert normalisiere(teststring) == 'hä returns nix'

AssertionError:

Wörter insgesamt zählen#

Gegeben:

  • die Liste psm_Beschreibungen_normalisiert_list aller normalisierten Beschreibungen

Gesucht:

  • Eine Zählung von Wörtern über alle Zeilen hinweg: Wie oft kommt in insgesamt allen Beschreibungen jedes Wort vor?

Randbedingung

  • Wörter mit bis zu 3 Zeichen Länge sind fast immer unspezifisch und bedeutungsarm. Wir ignorieren aller Wörter mit weniger als 4 Zeichen Länge.

Zu erzeugende Datenstruktur: ein Dict psm_Woerter_dict, das zu jedem Wort seine Anzahl insgesamt in allen Beschreibungen angibt.

  • {'converts': 5, 'first': 2, 'character': 2, 'upper': 5, ...} 

psm_Woerter_dict = {}

for zeile in psm_Beschreibungen_normalisiert_list:
    #print(f"Zeile: {zeile.split()}")
    for wort in zeile.split():
        if len(wort) >= 4:
            ... # 
                ... # 
            ... # 
                ... # 
        
print(f"Anzahl Wörter: {len(psm_Woerter_dict)}\n{psm_Woerter_dict}")

  Cell In [16], line 8
    ... #
    ^
IndentationError: unexpected indent

assert len(psm_Woerter_dict) == 75

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In [17], line 1
----> 1 assert len(psm_Woerter_dict) == 75

NameError: name 'psm_Woerter_dict' is not defined

Wort-Zählung pro Beschreibung#

Aufgabe wie bei vorangehenden Wörter-Zählung, aber Aufgabe jetzt: Zählung für jede Beschreibung separat.

Gegeben:

  • die Liste psm_Beschreibungen_normalisiert_list aller normalisierten Beschreibungen

Gesucht:

  • Eine Zählung von Wörtern für jede Zeile separat: Wie oft kommt ein Wort in jeder Zeile vor?

Auch hier beschränken wir uns wieder auf Wörter mit mindestens 4 Zeichen Länge.

Zu erzeugende Datenstruktur: eine Liste psm_Beschreibungen_normalisiert_list_of_dicts von Dicts; jedes Dict gibt zum jeweiligen Wort die Häufigkeit an. Beispiel:

[ {'converts': 1, 'first': 1, 'character': 1, ... },
  {'converts': 1, 'string': 1, 'into': 1, ...},
  {'returns': 1, 'centered': 1, 'string': 1}, 
  ... ]`

psm_Beschreibungen_normalisiert_list_of_dicts = []

for zeile in psm_Beschreibungen_normalisiert_list:
    d = {}
    ... # 
        ... # 
            ... # 
                ... # 
            ... # 
                ... # 
    psm_Beschreibungen_normalisiert_list_of_dicts.append(d)

psm_Beschreibungen_normalisiert_list_of_dicts[:3]

  Cell In [18], line 6
    ... #
    ^
IndentationError: unexpected indent

[ {‘converts’: 1, ‘first’: 1, ‘character’: 1, ‘upper’: 1, ‘case’: 1}, {‘converts’: 1, ‘string’: 1, ‘into’: 1, ‘lower’: 1, ‘case’: 1}, {‘returns’: 1, ‘centered’: 1, ‘string’: 1}]

Wort-Frequenz pro Beschreibung (freiwillig)#

Aufgabe: absolute Zählung relativieren, insbesondere in relatives “Gewicht” umrechnen.

Hintergrund: In unseren Funktionsbeschreibungen kommt das Wort string sehr oft vor, und sagt deshalb sehr wenig über die jeweilige Funktion aus. Anders Wörter wie z.B. upper oder trim: Sie sind selten und beschreiben deshalb sehr spezifisch eine bestimmte Funktion.

Sei das “Gewicht” eines Wortes:

  • seine Häufigkeit in einem bestimmten Text

  • geteilt durch seine Häufigkeit in allen Texten

Gegeben ist bereits die Häufigkeit eines Wortes:

  • in einer Beschreibung: psm_Beschreibungen_normalisiert_list_of_dicts

  • im Gesamttext: psm_Woerter_dict

Gesucht:

  • das Gewicht jedes Wortes für jede Zeile separat

Auch hier beschränken wir uns wieder auf Wörter mit mindestens 4 Zeichen Länge.

Zu erzeugende Datenstruktur: eine Liste von Dicts; jedes Dict gibt zum jeweiligen Wort sein Gewicht an.

# psm_Beschreibungen_normalisiert_list_of_dicts[:3]

# print(psm_Woerter_dict)

psm_Beschreibungen_normalisiert_list_of_dicts_gewicht = []

for zeile_dict in psm_Beschreibungen_normalisiert_list_of_dicts:
    #print(zeile_dict)
    
    zeile_gewicht_dict = {}
    for wort in zeile_dict.keys(): 
        ... # 
        
    psm_Beschreibungen_normalisiert_list_of_dicts_gewicht.append( zeile_gewicht_dict )

psm_Beschreibungen_normalisiert_list_of_dicts_gewicht[:3]

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In [21], line 3
      1 psm_Beschreibungen_normalisiert_list_of_dicts_gewicht = []
----> 3 for zeile_dict in psm_Beschreibungen_normalisiert_list_of_dicts:
      4     #print(zeile_dict)
      6     zeile_gewicht_dict = {}
      7     for wort in zeile_dict.keys(): 

NameError: name 'psm_Beschreibungen_normalisiert_list_of_dicts' is not defined

Als Ergebnis erhalten wir einen sogenannten Bag of Words, hier in der einigermaßen informativen Version *Dokumenthäufigkeit geteilt durch absolute Häufigkeit”.

Die erzeugte Datenstruktur ist eine Liste von Records – die man selbstverständlich auch in ein DataFrame überführen kann:

import pandas as pd

psm_bow_df = pd.DataFrame.from_records(psm_Beschreibungen_normalisiert_list_of_dicts_gewicht)

#waagrechte Darstellung
psm_bow_df.head()