Informatik M24b

Bei Listen sind die Elemente durchgehend nummeriert. Mit Dictionaries bietet Python einen weiteren zusammengesetzten Datentyp an, wobei jedes Element aus zwei Teilen besteht: einem Schlüssel und einem Wert. Dabei ersetzt der Schlüssel sozusagen die Nummerierung der Liste. Der Schlüssel muss eindeutig sein.

dictionary = {"am": "Vormittag", "pm": "Nachmittag"}

for key in dictionary:
    print("  key:", key)
    print("value:", dictionary[key])
    print()
1
2
3
4
5
6

# Dictionary definieren

Python erkennt Dictionaries an Hand der geschweiften Klammern. Vorgegebene Werte werden duch Kommas getrennt. Der Dictionary kann aber auch leer sein. Jeder Eintrag besteht aus einem Key und einem Wert, getrennt durch einen Doppelpunkt.

wochentage = {                  # Dictionary mit 3 Elementen
    "Mo": "Montag",
    "Di": "Dienstag",
    "Mi": "Mittwoch"
}  
monate = {1: "Jan", 12: "Dez"}  # Dictionary mit einem Elemente
jahre = {}                      # leerer Dictionary
1
2
3
4
5
6
7

# Anzahl Einträge

Mit len(dict) erhält man die Anzahl Elemente des Dictionarys dict.

# Auf Werte einzelner Elemente zugreifen

Möchte man auf die Werte einzelner Elemente des Dictionarys zugreifen, so muss man deren Schlüssel kennen. Man schreibt den Namen des Dictionarys und hängt in eckiger Klammer den Schlüssel des gewünschten Elementes an.

wochentage = {
    "Mo": "Montag",
    "Di": "Dienstag",
    "Mi": "Mittwoch"
} 
dienstag = wochentage["Di"]
print("Di ist die Abkürzung für", dienstag)
1
2
3
4
5
6
7

Aufgabe «Würfelsumme»

Wir versuchen Würfe mit zwei Würfeln zu simulieren. Dabei würfeln wir 1000 mal und merken uns dabei jeweils die Augensumme der beiden Würfel. Das Ergebnis sollte ein Verteilung der möglichen summierten Augenpunkten sein.

Eine mögliche Vorgehensweise wäre:

  • Verteilung als Dictionary definieren: als Schlüssel alle möglichen Augensummen, als Startwert überall eine 0
  • 1000 Würfe simulieren in einer while-Schleife mit Hilfe einer Zählvariablen und Zufallszahlen für die Würfel, dabei jeweils den Dictionary an der entsprechenden Stelle (Augensumme) eins vergrössern
  • Nach der Schleife den Dictionary ausgeben
«Würfelsumme» 
from random import randint

verteilung = {}
augensumme = 2
while augensumme <= 12:
    verteilung[augensumme] = 0
    augensumme = augensumme + 1

anzahl_wuerfe = 0
while anzahl_wuerfe < 1000:
    wuerfel1 = randint(1,6)
    wuerfel2 = randint(1,6)
    augensumme = wuerfel1 + wuerfel2
    verteilung[augensumme] = verteilung[augensumme] + 1
    anzahl_wuerfe = anzahl_wuerfe + 1
    
print(verteilung)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Zufallszahlen

Bis jetzt hatten wir Zufallszahlen zwischen 0 und 1 verwendet. Mit x = random.randint(a,b) kannst du eine ganze Zufallszahl generieren, so dass gilt.

# for-in-Schleife

Die for-in-Schleife beim Dicitionary iteriert über die Schlüssel der Elemente. Mit dem Schlüssel können wir aber die Werte erhalten:

dictionary = {"am": "Vormittag", "pm": "Nachmittag"}

for key in dictionary:
    print("  key:", key)
    print("value:", dictionary[key])
    print()
1
2
3
4
5
6

Aufgabe «Notendurchschnitt 2»

Berechne den Notendurchschnitt über alle Fächer mit der gegebenen Vorlage:

noten = {
    "Math": 4.5,
    "Deutsch": 5.5,
    "Geo": 6,
    "Sport": 4.75
}
1
2
3
4
5
6
«Notendurchschnitt 2» 
noten = {
    "Math": 4.5,
    "Deutsch": 5.5,
    "Geo": 6,
    "Sport": 4.75
}
summe = 0
for fach in noten:
    summe = summe + noten[fach]

durchschnitt = summe/len(noten)
1
2
3
4
5
6
7
8
9
10
11

# Elemente hinzufügen

Neue Elemente können direkt gesetzt werden. Man macht eine Zuweisung mit einen neuen Schlüssel:

wochentage = {
    "Mo": "Montag",
    "Di": "Dienstag",
    "Mi": "Mittwoch"
} 
wochentage["Do"] = "Donnerstag"
1
2
3
4
5
6

# Elemente entfernen

Um ein Element zu entfernen muss man dessen Schlüssel kennen. Dann kann man es mit der Methode pop() entfernen:

wochentage = {
    "Mo": "Montag",
    "Di": "Dienstag",
    "Mi": "Mittwoch"
} 
wochentage.pop("Mi")
1
2
3
4
5
6

Aufgabe «Textanalyse 3»

Wir wollen für einen vorgegeben Text eine Buchstabenhäufigkeitstabelle erstellen. Mit einer Liste ist das etwas umständlich. Aber ein Dictionary ist dafür sehr gut geeignet: Jeder Buchstabe des Textes erhält einen Eintrag, wobei der Schlüssel der Buchstabe selbst ist. Als Wert merkt man sich wie oft dieser Buchstabe im Text vorkommt.

«Textanalyse 3» 
def textanalyse(text):
    haeufigkeit = {}
    for zeichen in text:
        zeichen_klein = zeichen.lower()
        if zeichen_klein.isalpha():
            if zeichen_klein in haeufigkeit:
                haeufigkeit[zeichen_klein] = haeufigkeit[zeichen_klein] + 1
            else:
                haeufigkeit[zeichen_klein] = 1
    return haeufigkeit

resultat = textanalyse("the quick brown fox jumps over the lazy dog")
print(resultat)

for key in sorted(resultat):
    print(key, ":", resultat[key])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# JSON

JSON steht für JavaScript Object Notation und hat sich in den letzten Jahren als Standard für automatisierte Schnittstellen im Web etabliert. Dabei werden eigentlich Dictionaries und Listen kombiniert und mit [] und {} dargestellt:


 

 
 
 









{
    "drinks" : [
        {
            "name" : "sirup",
            "alcohol": false,
            "calories_per_liter": 220
        },
        {
            "name" : "beer",
            "alcohol": true,
            "calories_per_liter": 370
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Zeile 2
drinks ist der erste (und einzige) Eintrag des «Hauptdictionairies»
er besteht aus einer Liste von 2 Dictionaries
Zeile 4-6
Der erste Dictionary in der Liste drinks
Er besteht aus 3 Einträgen: Ein String name, ein Boolean alcohol und eine Zahl calories_per_liter

Die Internseite des Gymnasiums bietet einige solcher öffentlich zugänglichen JSON-Requests:

Termine
Liste der öffentlichen Termine des Gymers
👉 https://intern.gymkirchenfeld.ch/api/course/event/?startDate=2021-11-23&endDate=2022-01-31 (opens new window)
Ferien pro Schuhljahr
Liste aller Schuhljahre mit jeweils einer Liste der Ferien, also eine Liste mit Listen!
👉 https://intern.gymkirchenfeld.ch/api/common/holiday/?startDate=2021-08-01&endDate=2022-07-31 (opens new window)
Fächer des Gymers
Liste aller Fächer des Gymnasiums
👉 https://intern.gymkirchenfeld.ch/api/common/subject/ (opens new window)
Semester
Liste aller Semester
👉 https://intern.gymkirchenfeld.ch/api/common/term/ (opens new window)

So erhält man z.B. über die «subject»-URL eine Beschreibung aller am Gymer unterrichteten Fächer.

import requests
import json

data = requests.get(url="https://intern.gymkirchenfeld.ch/api/common/subject").json()
print(type(data))
print(data)

subjects = data["subjects"]
print(type(subjects))

for subject in subjects:
    print(subject["code"], ":", subject["description"])
1
2
3
4
5
6
7
8
9
10
11
12
Zeile 1 & 2
Libraries importieren
Zeile 4
mit der get-Methode des requests-Objektes wird ein https-Request gemacht und die Antwort mittels json() in einen Python-Dictionary umgewandelt
Zeile 8
wir greifen auf die Liste subjects zu
Zeile 11 & 12
Wir gehen die Liste Fach um Fach durch und zeigen Abkürzung und Beschreibung des Fachs

Zusatzaufgabe «JSON»

Wähle eine der 4 oben beschriebenen JSON-Schnittstellen unserer intern-Plattform aus

  • Erforsche die Struktur indem du die URL direkt im Browser öffnest (ev. kannst du JSON-Code online in einem Code-Formatter (opens new window) schöner darstellen)
  • Programmiere ein Python-Programm welches die Daten durchgeht und einige interessante Teile (so wie im Beispiel) ausgibt.
Letzte Änderung: 1. Dezember 2021 18:07

← Komplexität →