355 lines
10 KiB
Markdown
355 lines
10 KiB
Markdown
---
|
|
parent: "[[Lecture]]"
|
|
tags:
|
|
- Lecture
|
|
---
|
|
# Content
|
|
- [ ] Lösungen MatPlotLib, NumPy
|
|
- [ ] Ausgabe - SciPy
|
|
|
|
- [ ] Bernoulli Distributions
|
|
- [ ] Binomial Distributions
|
|
- [ ] Normal Distributions
|
|
- [ ] Regression
|
|
|
|
## 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](https://numpy.org/doc/stable/reference/generated/numpy.linspace.html#numpy-linspace) 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](https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html#numpy.sqrt) die Werte für die Wurzel.
|
|
3. Plotten Sie das Ergebnis
|
|
|
|
```python
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
|
|
# geeigneter Linespace für den Zahlenraum 0 bis 100
|
|
x = np.linspace (0, 100, 500) # 500 Punkte für eine glatte Darstellung
|
|
|
|
# Berechnen der Wurzelfunktion
|
|
y = np.sqrt(x)
|
|
|
|
# plotten der Ergebnisse
|
|
plt.plot(x, y, label="f(x)= √x")
|
|
plt.title("Plot der Wurzelfunktion")
|
|
plt.xlabel("x")
|
|
plt.ylabel("f(x)")
|
|
plt.grid(True)
|
|
plt.legend()
|
|
plt.show()
|
|
```
|
|
Alea Schleier
|
|
|
|
|
|
## Aufgabe[¶](https://jupyter2.ifn.ing.tu-bs.de:8000/user/instructor-einfhrung-in-die-prog/formgrader/submissions/14fa26f422cf4db2a97309e97b0bfdbd/?index=16#Aufgabe)
|
|
|
|
_6 Punkte_
|
|
|
|
Plote die Zufallszahlen eines _Permuted Congruent Generators_ mittels NumPy & MatPlotLib.
|
|
|
|
- Gegeben ist der Anfangszustand des Generators.
|
|
- Nutze die Dokumentation und rufe den `default_rng` aus dem `numpy.random` Modul, **20** mal auf speichere die Werte in der variablen `pcgs`. _(Tipp: Nutze ein NumPy Array)_
|
|
- Sortiere im nächsten Schritt die in `pcgs` gespeicherten Werte und speichere diese in `pcgs_sorted`
|
|
- Plotte sinnvoll beide Array. Gestalte den Plot angemessen.
|
|
|
|
```python
|
|
import numpy as np # Import NumPy
|
|
import matplotlib.pyplot as plt # Import Matplotlib for plotting
|
|
|
|
# 1. Setting the random seed
|
|
np.random.seed(42)
|
|
|
|
# 2. Generate 20 random numbers using the default_rng generator
|
|
rng = np.random.default_rng() # Initialize the default random number generator
|
|
pcgs = rng.random(20) # Generate 20 random numbers
|
|
|
|
# 3. Sort the generated numbers and store them in pcgs_sorted
|
|
pcgs_sorted = np.sort(pcgs) # Sort the numbers
|
|
|
|
# 4. Print the generated arrays for verification
|
|
print("PCGs:", pcgs)
|
|
print("Sorted PCGs:", pcgs_sorted)
|
|
|
|
# 5. Plot both arrays
|
|
plt.figure(figsize=(8, 6))
|
|
plt.plot(pcgs, label='PCGs (Unsorted)', linestyle='dashed', marker='o')
|
|
plt.plot(pcgs_sorted, label='PCGs (Sorted)', linestyle='solid', marker='x')
|
|
plt.title('Permuted Congruent Generator: Unsorted vs Sorted')
|
|
plt.xlabel('Index')
|
|
plt.ylabel('Value')
|
|
plt.legend()
|
|
plt.grid(True)
|
|
plt.show()
|
|
```
|
|
Abdalaziz Abunjaila
|
|
|
|
```python
|
|
np.random.seed(42) # Setting a fixed start Value for the Generator
|
|
pcgs: np.array = None
|
|
pcgs_sorted: np.array = None
|
|
|
|
#mycode
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
|
|
rng = np.random.default_rng(seed=42)
|
|
|
|
pcgs = np.array([rng.random() for _ in range(20)])
|
|
|
|
pcgs_sorted = np.sort(pcgs)
|
|
|
|
plt.figure(figsize=(10, 5))
|
|
|
|
plt.plot(pcgs, label="PCG Zufallszahlen", color='blue', marker='o', linestyle='--')
|
|
|
|
plt.plot(pcgs_sorted, label="Sortierte PCG Zufallszahlen", color='green', marker='x', linestyle='-')
|
|
|
|
plt.title("PCG Zufallszahlen und sortierte PCG Zufallszahlen")
|
|
plt.xlabel("Index")
|
|
plt.ylabel("Wert")
|
|
plt.legend()
|
|
|
|
plt.show()
|
|
```
|
|
Donika Nuhiu
|
|
|
|
```python
|
|
np.random.seed(42) # Setting a fixed start Value for the Generator
|
|
pcgs: np.array = None
|
|
pcgs_sorted: np.array = None
|
|
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
|
|
# Erstellen des Zufallsgenerators und Generation von 20 Zufallszahlen
|
|
rng = np.random.default_rng() # Initialisiere den Permuted Congruent Generator
|
|
pcgs = rng.random(20) # 20 Zufallszahlen erzeugen und in ein NumPy Array speichern
|
|
|
|
# Sortieren der Zufallszahlen
|
|
pcgs_sorted = np.sort(pcgs)
|
|
|
|
# Plotten der Ergebnisse
|
|
plt.figure(figsize=(10, 6))
|
|
|
|
# Original Zufallszahlen
|
|
plt.plot(pcgs, marker='o', linestyle='-', color='blue', label='Original-Zufallszahlen')
|
|
|
|
# Sortierte Zufallszahlen
|
|
plt.plot(pcgs_sorted, marker='x', linestyle='--', color='red', label='Sortierte Zufallszahlen')
|
|
|
|
# Gestalte den Plot
|
|
plt.title("Vergleich: Original- und sortierte Zufallszahlen")
|
|
plt.xlabel("Index")
|
|
plt.ylabel("Zufallswert")
|
|
plt.grid(True)
|
|
plt.legend()
|
|
|
|
plt.show()
|
|
```
|
|
Alea Schleier
|
|
|
|
```python
|
|
np.random.seed(42) # Setting a fixed start Value for the Generator
|
|
pcgs: np.array = None
|
|
pcgs_sorted: np.array = None
|
|
|
|
# YOUR CODE HERE
|
|
rng = np.random.default_rng(42)
|
|
pcgs = rng.random(20)
|
|
pcgs_sorted = np.sort(pcgs)
|
|
|
|
x = np.linspace(0, 20, num=20)
|
|
|
|
plt.plot(x, pcgs, color='c', label='Zufallszahlen')
|
|
plt.plot(x, pcgs_sorted, color='b', label='Zufallszahlen (sortiert)')
|
|
|
|
plt.title('Zufallszahlen eines PCG')
|
|
plt.xlabel('Index')
|
|
plt.ylabel('Wert')
|
|
|
|
plt.xlim(0, 20)
|
|
plt.ylim(0, 1.25)
|
|
plt.xticks(np.arange(0, 20, step=3))
|
|
plt.yticks(np.arange(0, 1.25, step=0.2))
|
|
|
|
mean_value = np.mean(pcgs)
|
|
plt.axhline(y=mean_value, color='r', linestyle="dashed", label=f'Durchschnitt: {mean_value:.2f}')
|
|
|
|
plt.legend()
|
|
plt.show()
|
|
```
|
|
Nova Eib
|
|
|
|
```python
|
|
np.random.seed(42) # Setting a fixed start Value for the Generator
|
|
pcgs: np.array = None
|
|
pcgs_sorted: np.array = None
|
|
|
|
# YOUR CODE HERE
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
|
|
rng = np.random.default_rng(seed=42)
|
|
|
|
pcgs = rng.random(20)
|
|
|
|
pcgs_sorted = np.sort(pcgs)
|
|
|
|
plt.figure(figsize=(10, 6))
|
|
|
|
plt.plot(pcgs, 'o-', label='Unsortiert')
|
|
|
|
plt.plot(pcgs_sorted, 's-', label='Sortiert')
|
|
|
|
plt.title('Zufallszahlen eines Permuted Congruent Generators')
|
|
plt.xlabel('Index')
|
|
plt.ylabel('Wert')
|
|
plt.grid(True)
|
|
plt.legend()
|
|
|
|
plt.show()
|
|
```
|
|
Izabel Mike
|
|
|
|
### Aufgabe[¶](https://jupyter2.ifn.ing.tu-bs.de:8000/user/instructor-einfhrung-in-die-prog/formgrader/submissions/f483499addec4dd8886a0ee278677732/?index=21#Aufgabe)
|
|
|
|
_5 Punkte_
|
|
|
|
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
|
|
|
|
```python
|
|
import matplotlib.pyplot as plt
|
|
|
|
sec_school = {
|
|
'5. Klasse': 29,
|
|
'6. Klasse': 35,
|
|
'7. Klasse': 25,
|
|
'8. Klasse': 28,
|
|
'9. Klasse': 31
|
|
}
|
|
|
|
bar_colors = ["purple", "blue", "green", "orange", "red"]
|
|
|
|
plt.bar(sec_school.keys(), sec_school.values(), color=bar_colors)
|
|
|
|
plt.xlabel("Klassenstufen")
|
|
plt.ylabel("Anzahl Schüler")
|
|
plt.title("Anzahl der Schüler pro Klassenstufe in der Hauptschule")
|
|
|
|
plt.show()
|
|
```
|
|
Donika Nuhiu
|
|
|
|
```python
|
|
import matplotlib.pyplot as plt
|
|
|
|
sec_school = {
|
|
'5. Klasse': 29,
|
|
'6. Klasse': 35,
|
|
'7. Klasse': 25,
|
|
'8. Klasse': 28,
|
|
'9. Klasse': 31
|
|
}
|
|
|
|
colors = ['blue', 'green', 'orange', 'purple', 'red']
|
|
|
|
grades = list(sec_school.keys()) # Klassenstufen
|
|
students= list(sec_school.values()) # Schüleranzahl
|
|
|
|
plt.bar (grades, students, color=colors)
|
|
|
|
plt.xlabel("Klassenstufen")
|
|
plt.ylabel("Anzahl der Schüler")
|
|
|
|
plt.title("Schüleranzahl pro Klassenstufe in der Hauptschule")
|
|
|
|
plt.grid(axis='y', linestyle='--', alpha=0.7) # Gitterlinie zur besseren Lesbarkeit
|
|
plt.show()
|
|
```
|
|
Alea Schleier
|
|
|
|
```python
|
|
bar_colors = ["red", "orangered", "darkorange", "orange", "gold"]
|
|
|
|
plt.bar(sec_school.keys(), sec_school.values(), color=bar_colors)
|
|
|
|
plt.title("Klassenverteilung (Hauptschule)")
|
|
plt.ylabel("Anzahl Kinder")
|
|
plt.xlabel("Klassenstufen")
|
|
|
|
# Ich finde die Werte der x- und y-Achse schon passend, also mach mich wenn dann für meine Fehleinschätzung und nicht für meinen Analphabetismus fertig, ich habe den Punkt gelesen, danke
|
|
|
|
mean_value = np.mean(list(sec_school.values()))
|
|
plt.axhline(y=mean_value, color='blue', linestyle="dashed", label=f'Durchschnitt: {mean_value:.2f}')
|
|
|
|
plt.legend()
|
|
plt.show()
|
|
```
|
|
Nova Eib
|
|
## Aufgabe[¶](https://jupyter2.ifn.ing.tu-bs.de:8000/user/instructor-einfhrung-in-die-prog/formgrader/submissions/a02d96d8a5c8452b91ac790b5fb5ce9b/?index=24#Aufgabe)
|
|
|
|
_5 Punkte_
|
|
|
|
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)
|
|
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.
|
|
|
|
```python
|
|
import matplotlib.pyplot as plt
|
|
|
|
#geeignetes Farbschema definieren, Kontrastreiche Farben zur einfachen Unterscheidung
|
|
colors = ['#ff6f61', '#6b5b95', '#88b04b', '#f7cac9', '#92a8d1']
|
|
|
|
#extrahieren der Werte und Schlüssel
|
|
keys = list (sec_school.keys())
|
|
values = list (sec_school.values())
|
|
|
|
#explodieren der 6. und 9. Klassenstufe
|
|
explode = [0, 0.25, 0, 0, 0.4]
|
|
|
|
plt.pie(values, labels = keys, colors = colors, autopct = '%1.1f%%', startangle = 90, explode = explode)
|
|
plt.title ('Verteilung der Schüler*innen auf die unterschiedlichen Klassenstufen')
|
|
plt.axis ('equal')
|
|
|
|
plt.show()
|
|
```
|
|
Lara Troschke
|
|
|
|
```python
|
|
pie_colors = ["red", "orangered", "darkorange", "orange", "gold"]
|
|
|
|
plt.pie(sec_school.values(), labels=sec_school.keys(), autopct='%1.1f%%', explode=[0, 0.25, 0, 0, 0.4], colors=pie_colors)
|
|
|
|
plt.title("Klassenverteilung (Hauptschule)")
|
|
|
|
plt.show()
|
|
```
|
|
Nova Eib
|
|
|
|
```python
|
|
pie_colors = ["lightpink", "darkseagreen", "mistyrose", "cadetblue", "rosybrown"]
|
|
|
|
plt.pie(sec_school.values(), labels=sec_school.keys(), autopct='%1.1f%%', explode=[0, 0.25, 0, 0, 0.4], colors=pie_colors)
|
|
|
|
plt.title("Klassenverteilung einer Hauptschule")
|
|
|
|
plt.show()
|
|
```
|
|
Julia Limbach |