# random_np_matplotlib_lösungen slides

# Ergebnisse¶

# Random Numbers¶

Aufgabe: Fühle die gegebene leere Liste `rands` mit 10 Zufälligen Werten zwischen 1 & 10, mittels der Funktion `random.randint`.

In [14]:

    rands = [random.randint(1,10) for _ in range(10)]
    rands

Out[14]:

    [5, 10, 7, 4, 2, 4, 4, 4, 4, 5]

Aufgabe: Gegeben sei die Liste `gaussians`; Setzen Sie den Seed des Zufallsgenerator auf den Wert `420` und füllen Sie die Liste `gaussians` mit `20` Elementen mittels der Funktion `random.gauss`. Dabei soll $\mu = 50$ sein.

In [15]:

    random.seed(420)
    gaussians = [random.gauss(mu=50, sigma=1.0) for _ in range(20)]
    plt.plot(range(len(gaussians)), gaussians)
    plt.show()

## Aufgabe¶

Schreibe einen Linear Congruent Generator mit dem funktionsnamen lcg.

In [31]:

    def lcg(seed: int, scalar: int, modulus: int, offset: int) -> int:
        '''
        Linear Congruential Generators

        X(n+1) = (a X(n) + c) mod m; n >= 0

        m > 0;
        0 <= a < m;
        c > 0; a > 0

        '''
        assert modulus > 0, "Modulus must be greater than 0"
        assert 0 <= scalar and scalar < modulus, "Scalar must be in range 0 <= a < m"
        assert seed >= 0, "Seed must be greater than 0"
        return (scalar*seed+offset) % modulus

    print('.'.join(wrap(str(lcg(3935559000370003845, 3203021881815356449, 2**64-1, 11742185885288659963)), 3)))

    308.981.078.012.015.624.8

## Aufgabe¶

Nutze die vorher geschriebene `lcg` Funktion, um einen `mcg` korrekt zu implementiert.

In [30]:

    def mcg(seed: int, scalar: int, modulus: int) -> int:
        '''
        Multiplicative Congruential Generator
        or Lehmer Generator

        Just the same as lcg with the Property c=0 (offset = 0)
        '''
        return lcg(seed, scalar, modulus, 0)

    print('.'.join(wrap(str(mcg(3935559000370003845, 3203021881815356449, 2**64-1)), 3)))

    979.436.896.854.104.790.0

## Aufgabe¶

Definieren Sie eine Variable `sg`, welche eine `SeedSequence` mit dem Startwert `42` hat. Nutzen Sie die verlinkte Dokumentation Numpy PCG64 als Referenz.

In [36]:

    sg = SeedSequence(42)
    sg

Out[36]:

    SeedSequence(
        entropy=42,
    )

## Aufgabe¶

Nutzen Sie ihre aus letzter Aufgabe erstellte `SeedSequence sg` und erzeugen Sie mittels `Generator` & `PCG64`, 10 Zufallszahlen in der vorgegebenen Liste `pcgs`. Als Referenz schauen Sie gerne in das Beispiel der Dokumentation Numpy PCG64.

In [41]:

    pcgs = list()
    sg = SeedSequence(42) # Benötigt keine erneute Definition
    for s in sg.spawn(10):
        pcgs.append(Generator(PCG64(s)).random())

In [66]:

    sg = SeedSequence(42) # Benötigt keine erneute Definition
    pcgs = [
        Generator(PCG64(s)).random()
        for s in SeedSequence(42).spawn(10)
    ]

In [44]:

    plt.plot(range(len(pcgs)), pcgs, color='r', label='PCG')
    plt.title("PCG Random Numbers")
    plt.legend()
    plt.show()

## Aufgabe - Zufallswerte generieren¶

Nutzen Sie ihr Wissen aus vorangegangem Kapitel und füllen Sie die Liste `clients` mit 60 zufälligen Werten aus einem PCG64. Nutzen Sie als Startwert `420` für die `SeedSequence`.

In [67]:

    clients = [
        Generator(PCG64(s)).random()
        for s in SeedSequence(420).spawn(60)
    ]

In [65]:

    clients = list()
    sg = SeedSequence(420) # Benötigt keine erneute Definition
    for s in sg.spawn(60):
        clients.append(Generator(PCG64(s)).random())

In [52]:

    plt.plot(range(len(clients)), clients, color='r', label='Clients')
    plt.title("Verkehrsaufkommen an einer Antenne (in % pro minute)")
    plt.legend()
    plt.show()

## Aufgabe - Verkehrswert berechnen¶

Der Verkehrswert berechnet sich mit $$y = \frac{Y}{t}$$

Dabei ist:

- $Y$ die Verkehrsmenge
- $t$ die Beobachtungsdauer (in minuten)

Der Verkehrswert beschreibt die mittlere Nutzung pro Minute.

Nutzen Sie die gegebene Formel und die Liste `clients` um den Verkehrswert zu berechnen. Speichern Sie das Ergebnis in der Variablen `y`.

In [53]:

    y = sum(clients)/len(clients)
    y

Out[53]:

    0.5221268844976396

In [56]:

    y = np.mean(clients)
    y

Out[56]:

    0.5221268844976394

Besser Formatiert:

In [62]:

    print("{:.2f}%".format(y*100))

    52.21%

In [60]:

    plt.plot(range(len(clients)), clients, color='b', label='Clients')
    plt.plot(range(len(clients)), [y for _ in range(len(clients))], color='y', label='Verkehrswert')
    plt.title("Verkehrsaufkommen an einer Antenne (in % pro minute)")
    plt.legend()
    plt.show()

# Numpy¶

## Aufgabe¶

Erstellen Sie ein NumPy Array, welches 6 Nullen reserviert und speichern Sie das Array in der Variablen `only_zeros`.

In [4]:

    only_zeros = np.zeros(6)
    only_zeros

Out[4]:

    array([0., 0., 0., 0., 0., 0.])

## Aufgabe¶

Erstellen Sie ein NumPy Array mit 11 Elementen mittels `linspace`, Dabei soll der Startwert = -4 und der Endwert = 17 sein. Speichern Sie das Ergbniss in der Variablen `x_scale`.

In [5]:

    x_scale = np.linspace(-4, 17, num=11)
    x_scale

Out[5]:

    array([-4. , -1.9,  0.2,  2.3,  4.4,  6.5,  8.6, 10.7, 12.8, 14.9, 17. ])

## Aufgabe¶

Ihnen ist das Array `pcgs` gegeben dieses enthält zufällige Zahlen eines Permuted Congruent Generators. Nutzen Sie Numpy um die Werte des Arrays `pcgs` zu sortieren. Speichern Sie ihr Ergebnis in der Variablen `sorted_pcgs`.

In [7]:

    from numpy.random import SeedSequence, Generator, PCG64
    sg = SeedSequence(42)
    pcgs = [Generator(PCG64(s)).random()*100 for s in sg.spawn(20)]
    pcgs

Out[7]:

    [91.67441575549084,
     46.74907799518424,
     7.123920291270869,
     76.39328676507445,
     1.7567502091441867,
     25.302055214458075,
     63.618561250625696,
     0.1579146041553514,
     70.96566546463475,
     29.830322658786066,
     32.993271323881935,
     85.498191941231,
     28.897614421550255,
     7.23902480784705,
     70.31144257136475,
     24.870797377171648,
     15.503033920124121,
     20.10861125030664,
     46.93021735717943,
     47.12091752159737]

In [9]:

    sorted_pcgs = np.sort(pcgs)
    sorted_pcgs

Out[9]:

    array([ 0.1579146 ,  1.75675021,  7.12392029,  7.23902481, 15.50303392,
           20.10861125, 24.87079738, 25.30205521, 28.89761442, 29.83032266,
           32.99327132, 46.749078  , 46.93021736, 47.12091752, 63.61856125,
           70.31144257, 70.96566546, 76.39328677, 85.49819194, 91.67441576])

In [10]:

    plt.plot(np.arange(len(sorted_pcgs)), pcgs, color='r', label='PCGs')
    plt.plot(np.arange(len(sorted_pcgs)), sorted_pcgs, color='g', label='Sortierte PCGs')
    plt.title("PCG Random Numbers")
    plt.legend()
    plt.show()

## Aufgabe¶

Schauen Sie in die NumPy Dokumentation zur Funktion reshape. Und shapen Sie das Array `n3` in eine Matrix der Form 3x2. Speicher Sie ihr Ergebnis in der Variablen `m23`.

In [12]:

    n3 = np.arange(21, 27) # Aus dem Beispiel
    m23 = n3.reshape((3, 2))
    m23

Out[12]:

    array([[21, 22],
           [23, 24],
           [25, 26]])

# Matplotlib¶

## Aufgabe - Erster eigener Plot Square Root¶

Analog zu voheriger Erklärung Plotten Sie im folgenden die Funktion Square Root Mathematisch definiert als $f(x) = \sqrt x; \quad x \geq 0$.

Gehen Sie dabei wie folgt vor:

1. Definieren Sie einen geeigneten Linespace für die Zahlenraum 0...100. (Tipp: Achten Sie auf die Definition! Die Wurzel ist nur für positive Zahlen definiert.)
2. Berechnen Sie mittels der Funktion np.sqrt die Werte für die Wurzel.
3. Plotten Sie das Ergebnis

In [3]:

    xs = np.linspace(0, 100, num=200)
    ys = np.sqrt(xs)
    plt.plot(xs, ys)
    plt.show()

In [6]:

    xs = np.linspace(0, 100, num=50)
    ys = np.sqrt(xs)
    plt.plot(xs, ys)
    plt.show()

## Aufgabe - Multiplot¶

In der nächsten Aufgabe wollen wir gleich zwei Funktionen Plotten. $f(x) = \sqrt x$ und $g(x) = x^2$.

Gehen Sie dabei wie folgt vor:

1. Definieren Sie einen geeigneten Linespace für die Zahlenraum 0...3. (Tipp: Achten Sie auf die Definition! Die Wurzel ist nur für positive Zahlen definiert.)
2. Berechnen Sie mittels der Funktion np.sqrt die Werte für die Wurzel.
3. Berechnen Sie mittels der Funktion np.square die Werte für die Quadrat Zahlen
4. Geben Sie den beiden Plots die Farben Grün & Rot. Nutzen Sie gerne die Color Shorthands aus der Dokumentation.
5. Plotten Sie die Square Funktion mit dem Linestyle `dashdot`, wie der Dokumentation zu entnehmen Linestyles
6. Geben Sie den beiden Plots angemessene Labels.
7. Fügen Sie die Legende hinzu.
8. Plotten Sie das Ergebnis.

In [4]:

    xt = np.linspace(0, 3, num=200)
    sqrt = np.sqrt(xt)
    square = np.square(xt)

    plt.plot(xt, sqrt, color='r', label="Square Root")
    plt.plot(xt, square, color='g', label="Square Function", linestyle="dashdot")
    plt.legend()
    plt.show()

### Aufgabe¶

Ihnen ist ein Datenset `sec_school` einer Hauptschule gegeben, welches die Klassenstufen von 5 bis 9 auf die Anzahl ihrer Schüler im Jahrgang mappt.

Definieren Sie einen Barplot. Gehen Sie dabei wie folgt vor:

1. Definieren Sie ein geeignetes Farbschema zur Darstellung der Daten.
2. Extrahieren Sie die Schlüssel und Werte aus dem Datenset und übergeben Sie diese zusammen mit den Farbwerten an die Funktion `plt.bar`.
3. Setzen Sie geeignete Werte für die X & Y-Achse.
4. Setzen Sie einen geeigneten Titel für den Plot.
5. Plotten Sie den Werte

In [69]:

    sec_school = {
        '5. Klasse': 29,
        '6. Klasse': 35,
        '7. Klasse': 25,
        '8. Klasse': 28,
        '9. Klasse': 31
    }

In [70]:

    colors = ["red", "blue", "green", "yellow", "pink"]
    plt.bar(sec_school.keys(), sec_school.values(), color=colors)
    plt.xlabel("Klassenstufe")
    plt.ylabel("Anzahl Kinder")
    plt.title("Verteilung Kinder einer Hauptschule pro Klassenstufe")
    plt.show()

# Student Answers¶

In [71]:

    bar_colors = ["lavender", "#C79FEF", "orchid", "plum", "purple"]

    plt.bar(sec_school.keys(), sec_school.values(), color=bar_colors)

    plt.ylabel("Anzahl Kinder")
    plt.xlabel("Klassenstufen")

    plt.show()

In [76]:

    colors = ['blue', 'green', 'orange', 'red', 'purple'] # Aufgabe 1
    # Aufgabe 2
    plt.bar(list(sec_school.keys()), list(sec_school.values()), color=colors)
    # Aufgabe 3, 4
    plt.xlabel('Klassenstufen')
    plt.ylabel('Anzahl der Schüler')
    plt.title('Anzahl der Schüler pro Klasse')
    plt.show() # Aufgabe 5

In [73]:

    bar_farbe = ['b','g','m','y','c']
    plt.bar(sec_school.keys(), sec_school.values(), color=bar_farbe)
    plt.ylabel("Anzahl der Kinder")
    plt.xlabel("Klassenstufen")
    plt.title("Hauptschulklassen")
    plt.plot()

Out[73]:

    []

In [78]:

    colors = ['skyblue', 'lightgreen', 'lightcoral', 'lightsalmon', 'lightseagreen']
    # Barplot erstellen # Schlüssel (Klassenstufen) und Werte (Anzahl der Schüler) extrahieren
    plt.bar(list(sec_school.keys()), list(sec_school.values()), color=colors)
    # Achsentitel setzen
    plt.xlabel('Klassenstufen')
    plt.ylabel('Anzahl der Schüler')
    plt.title('Anzahl der Schüler pro Klassenstufe')
    # Plot anzeigen
    plt.show()

In [79]:

    plt.title("Sekundarstufe Sonne&Beton Hauptschule")
    #color ist optionaler Parameter/Attribut der Funktion plt.bar definiert als leere Liste
    bar_colors = ["lightgrey", "yellow", "silver","darkgrey" ,"gold"]
    #übergeben Sie diese zusammen mit den Farbwerten an die Funktion plt.bar
    plt.bar(sec_school.keys(), sec_school.values(), color=bar_colors, edgecolor=["k"]) #Parameter color werden die Farben aus bar_colors übergeben
    plt.ylabel("Anzahl der Kinder") # Beschriften der Y-Achse
    plt.xlabel("Klassenstufe") # Beschriften der X-Achse
    plt.show()

## Aufgabe¶

Ihnen ist ein Datenset `sec_school` einer Hauptschule gegeben, welches die Klassenstufen von 5 bis 9 auf die Anzahl ihrer Schüler im Jahrgang mappt.

Definieren Sie einen Pieplot. Gehen Sie dabei wie folgt vor:

1. Definieren Sie ein geeignetes Farbschema zur Darstellung der Daten.
2. Extrahieren Sie die Schlüssel und Werte aus dem Datenset und übergeben Sie diese zusammen mit den Farbwerten an die Funktion `plt.pie`. (Nutzen Sie zum Anzeigen der Prozentwerte autopct='%1.1f%%')
3. Lassen Sie die 6. Klasse 25% und die 9. Klasse 40% explodieren.
4. Setzen Sie einen geeigneten Titel für den Plot.
5. Plotten Sie den Werte.

In [8]:

    plt.pie(
        sec_school.values(),
        labels=sec_school.keys(),
        autopct='%1.1f%%',
        explode=[0, 0.25, 0, 0, 0.4]
    )

    plt.title("Klassenverteilung einer Grundschule")

    plt.show()

# Student Answers¶

In [11]:

    sec_color = ['#93afdb','#92d1d0','#ad92d1','#d192c0','#d1b692']
    klassen = list(sec_school.keys())
    schülerzahl = list(sec_school.values())
    explode = (0, 0.25, 0, 0, 0.4)
    plt.title("Schülerverteilung der Hauptschule")
    plt.pie(schülerzahl, labels=klassen, colors=sec_color, autopct='%1.1f%%', explode=explode)
    plt.show()

In [13]:

    pie_colors = ["lightblue", "lightgreen", "lightcoral", "lightskyblue", "lightpink"]

    explode = (0, 0.1, 0, 0, 0.2)

    plt.pie(sec_school.values(), labels=sec_school.keys(), colors=pie_colors, autopct='%1.1f%%', explode=explode)
    plt.title("Anzahl der Schüler in verschiedenen Klassenstufen")
    plt.show()

In [14]:

    schluessel = list(sec_school.keys())
    werte = list(sec_school.values())
    farben = ['gold', 'yellowgreen', 'lightcoral', 'lightskyblue', 'purple']
    explode = (0, 0.25, 0, 0, 0.40)

    plt.pie(werte, explode=explode, labels=schluessel, colors=farben, autopct='%1.1f%%', shadow=True, startangle=140)
    plt.title('Verteilung der Klassenstärke')
    plt.axis('equal')

    plt.show()

In [17]:

    color_pie=("gold", "yellow", "gray", "silver", "lightgrey")
    plt.pie(sec_school.values(), labels=sec_school.keys(), colors=color_pie, autopct='%1.1f%%', explode=[0, 0.25, 0, 0, 0.40])

    plt.title("Klassenverteilung Sonne&Beton Hauptschule")

    plt.show()