Skip to content
Snippets Groups Projects
Commit 99c51b68 authored by Malte Woidt's avatar Malte Woidt
Browse files

Verlorengegangene Übung 2 wieder hinzugefügt

parent 396e3a51
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 959 additions and 0 deletions
Uebung02/Uebung02.ipynb 0 → 100644
+ 959
− 0
View file @ 99c51b68
%% Cell type:markdown id:757b9a6c-6599-4cd6-93c5-c4fb30ed5b53 tags:
# <font color='blue'>**Übung 2 - Steuerung des Programmablaufs**</font>
%% Cell type:markdown id:d3a49027-9186-48a6-ba9f-332428e93bd9 tags:
## <font color='blue'>**Die Grundlagen von Python Teil 2**</font>
Dieses Notebook wird in der zweiten Übung verwendet. Im ersten Teil der Python Grundlagen wurden Zahlen, Zeichenketten und Variablen behandelt. Die Übungsprogramme haben Rechenabläufe automatisiert, der Programmablauf innerhalb der Programme war aber immer linear und bei jeder Ausführung gleich, von den vorgegebenen Zahlenwerten abgesehen. Um wirklich sinnvolle Programme schreiben zu können reicht das noch nicht aus. In dieser Übung wird gezeigt, wie sich der Programmablauf verändern lässt. Außerdem wird die Liste als neuer Variablentyp eingeführt, die etwas anderen Regeln folgt als die bisher gezeigten Variablen. Wie in folgenden Notebooks, musst du dir für diese Übung etwas mehr Informationen aus dem Grundlagen-Notebook zusammensuchen. Die Regeln über lokale und globale Variablen und die mutable-Objects sind in diesem Notebook etwas detaillierter in ihrer Theorie beschrieben. Auch wenn nicht alles davon unmittelbar in dieser Übung wichtig wird, ist dieses grundsätzliche Verhalten für folgende Übungen immer wieder wichtig und gerade ohne Programmiererfahrung etwas schwierig zu durchblicken.\
Die Aufgaben in dieser Übung erfüllen schon eher einen konkreten Zweck, in der nächsten Übung werden wir anfangen, auch konkrete Ingenieursproblem zu betrachten.
### **Weitere Notebooks, die dir helfen könnten**
* Python Grundlagen Teil 1
* Python Grundlagen Teil 2
### **Vorkenntnisse**
* Übung 1
### **Lernziele**
* Schleifen
* Funktionen
* Verzweigungen
* Listen
* lokale und globale Variablen
* mutable Objects
%% Cell type:markdown id:b0e426c9-9a66-4bc6-a0be-fc8e08c18858 tags:
# <font color='blue'>**Abschnitt 1 - Schleifen**</font>
## <font color='blue'>*Aufgabe*</font>
Berechne die 25. Fibonacci-Zahl
## <font color='blue'>*Grundlagen*</font>
Die Fibonacci-Zahlen sind eine Folge ganzer Zahlen. In der hier verwendeten Definition beginnt die Folge mit:
$0,1,1,2,3,5,8,13,...$
Für die Zahlen gilt die Berechnungsvorschrift\
$f_{n}=f_{n-2}+f_{n-1}$ wenn $n>=3$\
$f_{1}=0$\
$f_{2}=1$
d.h. nach den ersten beiden vorgegebenen Zahlen ist jede Zahl die Summe ihrer beiden vorhergehenden Zahlen.
%% Cell type:markdown id:b29c819a-aedd-4232-bcd7-eedcd810695c tags:
## <font color='blue'>*Lösung*</font>
%% Cell type:code id:6b0c8c9d-f3b6-47fc-9de7-04f557ed5511 tags:
``` python
```
%% Cell type:markdown id:4086f815-c7a9-42d5-84ce-0068818069b7 tags:
## <font color='blue'>*Hintergründe*</font>
Mit den Informationen aus der ersten Übung sollte es dir bereits möglich sein zwei Zellen zu Programmieren, wobei die Zweite Zelle das Gewünschte Ergebnis nach 23 maliger Ausführung liefert. Probiere es einfach aus. Du brauchst für die Berechnung einer Fibonacci-Zahl die beiden vorhergehenden Zahlen. Definiere zwei Variablen fn_2 und fn_1 für die vorletzte und letzte Fiboncci-Zahl (also $f_{n-2}$ und $f_{n-1}$) und initialisiere sie mit 0 und 1, den ersten beiden Elementen der Folge. In einer zweiten Zelle kannst du das fn ($f_{n}$), also die nächste Fibonacci-Zahl aus den beiden anderen Variablen berechnen. Um für den nächsten Durchlauf alles vorzubereiten, speicherst du die Zahl aus fn_1 in fn_2 und die Zahl aus fn in fn_1. Damit wird beim nächsten Ausführen der Zelle die nächste Fibonacci-Zahl berechnet
%% Cell type:code id:7309e508-227e-4431-901b-4125b0f8ed65 tags:
``` python
```
%% Cell type:code id:8e27cc1a-62c2-4003-a6ab-4c8baff3cfaf tags:
``` python
```
%% Cell type:markdown id:a9309ddf-6566-4b7c-aa99-65df4a673004 tags:
Natürlich ist dieses Vorgehen nicht besonders zielführend. Du müsstest den Quellcode der zweiten Zelle mehrmals automatisch ausführen können. Das bezeichnet man als Schleife. Du kanst dir entsprechende Möglichkeiten im Grundlagen-Notebook anschauen und dir die Möglichkeit aussuchen, die dir besser gefällt. Wenn du die Zählervariable der Schleife bei 3 beginnen lässt, dann kannst du mit ihr auch ermitteln, welche Fibonacci-Zahl du tatsächlich berechnet hast.
%% Cell type:markdown id:46d21f3a-b37e-49d3-864f-587b09ba0b89 tags:
# <font color='blue'>**Abschnitt 2 - Funktionen**</font>
Ermögliche eine komfortablere Möglichkeit, beliebige Fibonacci-Zahlen zu berechnen. Erstelle dazu eine Funktion mit dem Namen "Fib", die als Parameter eine Zahl übergeben bekommt die bestimmt, die wie vielte Fibonacci-Zahl berechnet werden soll. Du kannst hierfür davon ausgehen, dass nur Parameter größer oder gleich 3 eingegeben werden. Die Fibonacci-Zahl sollte deine Funktion sinnvollerweise als Ergebnis zurückliefern
%% Cell type:markdown id:e7333454-be6d-487d-a39e-ba509472aa30 tags:
## <font color='blue'>*Lösung*</font>
%% Cell type:code id:dc85e62c-a188-46ab-b7c5-55fc44d8bbbf tags:
``` python
```
%% Cell type:markdown id:ba7ac092-04ed-4dac-99a6-9e4f702bd8f9 tags:
## <font color='blue'>*Grundlagen*</font>
Funktionen werden manchmal auch als Unterprogramme bezeichnet, was genauer beschreibt, was sie sind. In einer Funktion kann ein beliebig langer Abschnitt eines Programms unter einem Namen zusammengefasst werden. Der Programmabschnitt kann dann mit diesem Namen ausgeführt werden. Dadurch wird der in der Funktion enthaltene Quelltext einmal komplett ausgeführt. Dass kann innerhalb eines Programms auch mehrfach passieren, sodass Programmabschnitte, die mehrfach in einem Programm vorkommen, wiederverwendet werden können.
%% Cell type:code id:38945dd8-5519-4e80-8ae8-e1856287ac48 tags:
``` python
def ausgabe():
print ("Ausgabe von Text aus einer Funktion")
ausgabe()
ausgabe()
```
%% Output
Ausgabe von Text aus einer Funktion
Ausgabe von Text aus einer Funktion
%% Cell type:markdown id:f64925ee-5bc6-4fb6-a3ae-34fa4ecb0bfd tags:
Funktionen können optional Parameter besitzen. Diese werden in den runden Klammern angegeben. Die Parameter können bei der Definition der Funktion beliebig benannt werden und stehen dann innerhalb der Funktion als Variablen bereit. Den Wert, den diese Variablen am Start der Funktion haben, wird beim Aufruf der Funktion angegeben
%% Cell type:code id:c239c355-f89f-4c6a-9be1-7d5b50cf8c9e tags:
``` python
def ausgabe(name,wert):
print("Der Wert mit dem Namen "+name+" hat den Wert "+str(wert))
y=10
ausgabe("X",5)
ausgabe("Y",y)
```
%% Output
Der Wert mit dem Namen X hat den Wert 5
Der Wert mit dem Namen Y hat den Wert 10
%% Cell type:markdown id:8a2f2e31-b96a-4fcd-9ce5-88d9d2c5cee4 tags:
In diesem Beispiel wird die Funktion *ausgabe* mit zwei Parametern aufgerufen. "X" und 5. Statt einem Festwert können auch die Werte einer Variablen verwendet werden. Wenn die Funktion aufgerufen wird, muss die Anzahl der Parameter der Anzahl an Parametern in der Funktionsdefinition entsprechen. In diesem Fall werden die Parameter beim Aufruf in der selben Reihenfolge angegeben, wie sie in der Definition erscheinen. Im Grundlagen-Notebook sind weitere Möglichkeiten beschrieben.\
Wird eine Funktion ausgeführt, werden zu erst lokale Variablen mit dem Namen, wie in der Funktionsdefinition angegeben, erzeugt. Diesen wird dann das "X" und die 5 zugewiesen. Das Verhalten entspricht dabei dem des Zusweisungsoperators. Anschließend wird die Funktion ausgeführt. Die Variablen *name* und *wert* sind dabei lokale Variablen der Funktion. Das heißt, dass sie nach Beendigung der Funktion gelöscht werden.\
Funktionen können auch Werte zurückgeben. Zum Beispiel wenn sie etwas berechnet haben. Das Funktioniert mit einem *return*
%% Cell type:code id:5a7265f9-0db7-4972-8a68-40381455fd29 tags:
``` python
def addiere(x,y):
return x+y
y=addiere(3,2)
print(addiere(y,5))
```
%% Output
10
%% Cell type:markdown id:30600ff2-390a-4f5d-abae-310f67cc4dfd tags:
Das *return* beendet die Ausführung der Funktion sofort. Wenn noch Anweisungen hinter dem *return* stehen, werden diese nicht ausgeführt. Das *return* kann auch ohne anschließenden Wert verwendet werden, um die Funktion einfach nur zu beenden. Der Funktionsaufruf liefert einen Wert, als ob an der Stelle des Funktionsaufrufs eine Variable oder ein Festwert stehen würde. Daher kann das Ergebnis einer Funktion einer Variablen zugewiesen werden, oder auch direkt als Funktionsparameter (z.B. für print) verwendet werden.
Wenn ein Funktionsaufruf beendet wird, dann geht das Programm dort weiter, wo es durch den Funktionsaufruf unterbrochen wurde. Innerhalb einer Funktion können also weitere Funktionen aufgerufen werden
%% Cell type:code id:7fcac190-6fbf-461a-a458-6916577529f5 tags:
``` python
def funktion1():
print("Funktion 1 startet")
print ("Funktion 1 endet")
def funktion2():
print("Funktion 2 startet")
funktion1()
print("Funktion 2 endet")
funktion2()
```
%% Output
Funktion 2 startet
Funktion 1 startet
Funktion 1 endet
Funktion 2 endet
%% Cell type:markdown id:e858cbbf-331e-458b-ba55-907b2eb53a72 tags:
### lokale und globale Variablen in Python
In Python werden globale und lokale Variablen unterschieden. Das sind Ausdrücke mit denen die Sichtbarkeit und die Lebensdauer von Variablen beschrieben wird. In Python unterliegen die Regeln für diese Unterscheidung teilweise impliziten Regeln. Diese Regeln sind nicht zwingend logisch, sondern einfach definiert.
Eine kurze Beschreibung der Regeln:
* Auf globale Variablen kann überall im Programm zugegriffen werden
* Auf eine lokale Variable kann nur innerhalb der Funktion zugegriffen werden, in der sie erstellt wurde. Sie wird am Ende der Funktion wieder gelöscht
* Eine Variable die Außerhalb jeglicher Funktion definiert wird ist immer eine globale Variable
* Eine Variable, die innerhalb einer Funktion definiert wird, ist standardmäßig immer eine lokale Variable
* Besteht die Möglichkeit, dass innerhalb einer Funktion eine lokale Variable mit gleichem Namen wie eine globale Variable definiert wird, ist die globale Variable innerhalb der Funktion unsichtbar
* Soll innerhalb einer Funktion eine globale Variable definiert werden oder eine globale Variable neu zugewiesen werden, dann muss das Schlüsselwort global verwendet werden
Eine kurze Erläuterung zu den Regeln:\
Eine Variable, die außerhalb einer Funktion definiert wird ist global. Sofern innerhalb einer Funktion keine lokale Variable gleichen Namens vorhanden ist, kann auf globale Variablen zugegriffen werden
%% Cell type:code id:38b648f0-321b-43ec-aeaf-82fd5efdefb7 tags:
``` python
def ausgabe():#Eine Funktion kann mehrfach mit dem gleichen Namen definiert werden. Die alte Funktion wir dann einfach überschrieben!
print(x)
x=10#x wird außerhalb einer Funktion definiert, also ist sie global
ausgabe()
```
%% Output
10
%% Cell type:markdown id:bc02bae8-1a39-4b31-9659-500ab692579e tags:
Regel: Eine Variable, die innerhalb einer Funktion definiert wird ist eine lokale Variable. Sie wird am Ende der Funktion gelöscht und auf sie kann nur innerhalb der Funktion zugegriffen werden
%% Cell type:code id:589ff0c2-7acc-4771-900f-bb22f6b62106 tags:
``` python
def funktion1():
print (meineVariable)
def funktion2():
meineVariable=10#meineVariable ist eine lokale Variable der Funktion 'funktion2', sie ist nur innerhalb von 'funktion2' vorhanden
funktion1()
funktion2()
```
%% Output
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In [29], line 6
4 meineVariable=10
5 funktion1()
----> 6 funktion2()
Cell In [29], line 5, in funktion2()
3 def funktion2():
4 meineVariable=10
----> 5 funktion1()
Cell In [29], line 2, in funktion1()
1 def funktion1():
----> 2 print (meineVariable)
NameError: name 'meineVariable' is not defined
%% Cell type:markdown id:82b6ce17-16ee-4317-a37f-da9a4eea6e4a tags:
Die Variable *meineVariable* ist bzgl. der Funktion *funktion2* lokal. Wenn innerhalb dieser Funktion eine weitere Funktion aufgerufen wird, kann diese nicht auf lokale Variablen anderer Funktionen zugreifen.
Dieses Verhalten ist in vielen Programmiersprachen existend. Es ist zu beachten, dass alle lokalen Variablen einer Funktion mit beendigung der Funktion gelöscht werden. Sollten Funktionen von innerhalb der Funktion aufgerufen werden, sind die lokalen Variablen der aufrufenden Funktion für diese auch nicht sichtbar. Deshalb heißen diese Varialben lokal. Die lokalen Variablen sind genau genommen nicht einer Funktion zugeordnet sondern einem Funktionsaufruf (das heißt Funktionen können sich selbst aufrufen, jeder Aufruf hat dann seine eigenen lokalen Variablen)
Regel: Besteht die Möglichkeit, dass innerhalb einer Funktion eine lokale Variable mit gleichem Namen, wie eine globale Variable definiert wird, ist die globale Variable innerhalb der Funktion unsichtbar.\
%% Cell type:code id:c29f7a95-9657-414f-9f23-26b1668c9f90 tags:
``` python
globaleVariable=20#Eine globale Variable wird angelegt
def meineFunktion():
print(globaleVariable)#auf die globale Variable 'globaleVariable' kann nicht zugegriffen werden. Sie ist für die Funktion unsichtbar, da in der nächsten Zeile eine lokale Variable gleichen Namens angelegt wird. Sie ist damit innerhalb der kompletten Funktion unsichtbar.
globaleVariable=30
meineFunktion()
print(globaleVariable)
```
%% Output
---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
Cell In [15], line 5
3 print(globaleVariable)#auf die globale Variable 'globaleVariable' kann nicht zugegriffen werden. Sie ist für die Funktion unsichtbar, da in der nächsten Zeile eine lokale Variable gleichen Namens angelegt wird. Sie ist damit innerhalb der kompletten Funktion unsichtbar.
4 globaleVariable=30
----> 5 meineFunktion()
6 print(globaleVariable)
Cell In [15], line 3, in meineFunktion()
2 def meineFunktion():
----> 3 print(globaleVariable)#auf die globale Variable 'globaleVariable' kann nicht zugegriffen werden. Sie ist für die Funktion unsichtbar, da in der nächsten Zeile eine lokale Variable gleichen Namens angelegt wird. Sie ist damit innerhalb der kompletten Funktion unsichtbar.
4 globaleVariable=30
UnboundLocalError: local variable 'globaleVariable' referenced before assignment
%% Cell type:markdown id:92de3175-347e-4132-9d1a-c24776bed021 tags:
Innerhalb der Funktion "meineFunktion" wird in der Zeile 4 eine lokale Variable mit dem Namen "globaleVariable" angelegt. Deshalb ist die Globale Variable in der ganzen Funktion nicht sichtbar. Das heißt, man kann auch vor Definition der lokalen Variable nicht auf sie zugreifen. Das ist eine Art Schutzmechanismus, da ansonsten Programme extrem schwer verständlich geschrieben werden könnten.\
Dieses Verhalten geht so weit, dass der Fehler selbst ausgelöst wird, wenn die Erstellung der lokalen Variable unmöglich passieren kann (vgl. return beendet die Funktion sofort)
%% Cell type:code id:81dacbb1-4bd4-4300-857b-f16db227d023 tags:
``` python
globaleVariable=20
def meineFunktion():
print(globaleVariable)#Das gleiche Problem wie oben, obwohl praktisch gesehen die lokale Variable nie angelegt werden kann
return#Die Funktion endet hier garantiert. Die folgenden Zeilen der Funktion werden nie ausgeführt
globaleVariable=30
meineFunktion()
print(globaleVariable)
```
%% Output
---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
Cell In [65], line 6
4 return
5 globaleVariable=30
----> 6 meineFunktion()
7 print(globaleVariable)
Cell In [65], line 3, in meineFunktion()
2 def meineFunktion():
----> 3 print(globaleVariable)
4 return
5 globaleVariable=30
UnboundLocalError: local variable 'globaleVariable' referenced before assignment
%% Cell type:markdown id:92237f17-bbf2-483d-b95a-3b42ee6a1cd4 tags:
Falls innerhalb einer Funktion für eine Variable, die links vom Zuweisungsoperator steht, eine globale statt einer lokalen Variable angelegt werden soll, dann kann dieses Verhalten mit dem Schlüsselwort global ausgelöst werden. Die Verändert die Regel, dass in Funktionen angelegte Variablen lokale Variablen sind. Somit können sowohl neue globale Variablen angelegt werden als auch globale Variablen neu zugewiesen werden
%% Cell type:code id:02ef67a7-0708-4489-9a51-cda0335d62e5 tags:
``` python
globaleVariable=20
def meineFunktion():
global globaleVariable#der Name 'globaleVariable' bezieht sich jetzt für den Rest der Funktion immer auf die globale Variable mit diesem Name
global globaleVariable2#Das geht auch mit Variablen, die noch nicht angelegt wurden
globaleVariable2=10
print (globaleVariable)
globaleVariable=30
meineFunktion()
print(globaleVariable)#Die Variable wurde in der Funktion 'meineFunktion' verändert
print(globaleVariable2)#Die Variable wurde in der Funktion 'meineFunktion' neu erstellt
```
%% Output
20
30
10
%% Cell type:markdown id:9bf73a54-e24d-44ac-b2b6-0ba3e2072507 tags:
Globale Variablen sollten nur im Notfall innerhalb einer Funktion verändert werden. Oft kennt ein Programmierer beim Aufruf nur die Funktionsdefinition und einen Hilfetext zur Funktion und möchte sie nutzen, ohne den Inhalt komplett nachvollzogen zu haben. Bei der Funktion *meineFunktion* werden potentiell globale Variablen des Programms (man spricht auch von Zustand) verändert, ohne das von außen ersichtlich ist, dass das passiert. Gerade bei großen Programmen, an denen mehrere Personen beteiligt sind, ist so ein Verhalten äußerst problematisch, da die Auswirkungen auf das gesamte Programm unvorhersehbar wird (Jede globale Variable gibt es nur ein mal mit diesem Namen im gesamten Programm). Prinzipiell werden wir noch verschiedene Möglichkeiten kennen lernen, diese Effekte zu vermeiden. Vor dem Verändern von globalen Variablen in einer Funktion sollte man sich immer die Frage stellen, ob es nicht eine andere Möglichkeit gibt, das gleiche Verhalten zu erzeugen. In den allermeisten Fällen, sind die Alternativen besser.
%% Cell type:markdown id:e7c122a8-ae90-4fb2-9b17-4380442fb15f tags:
# <font color='blue'>**Abschnitt 3 - Verzweigungen**</font>
## <font color='blue'>**Aufgabe**</font>
Programmiere eine Funktion "istPrimzahl", die eine ganze Zahl als Parameter bekommt und ermittelt, ob es sich bei dieser Zahl um eine Primzahl handelt. Du kannst in dieser Übung den Parameter einfach in eine ganze Zahl umwandeln um sicherzustellen, das alles wie geplant funktioniert
## <font color='blue'>**Grundlagen**</font>
Eine ganze Zahl ist dann eine Primzahl, wenn sie durch keine andere Zahl als sich selbst und 1 ohne Rest teilbar ist. Die 0 und die 1 sind keine Primzahlen! \
Für eine Zahl $x$ sind potentielle ganzzahlige Teiler $[2,x//2]$. Das ist eine sehr einfache und daher auch sehr ineffiziente Einschränkung, aber für diese Aufgabe zum Üben in Ordnung. Beachte das die Hälfte der Zahl innerhalb des Intervals liegt (sonst würde die 4 fälschlicherweise als Prinzahl erkannt werden). Überprüfe anschließend die Zahlen von 1 bis 100, ob sie Primzahlen sind, und gebe alle Primzahlen aus und ermittle, wie viele Primzahlen bis 100 es gibt. (Zum Überprüfen deines Erbebnisses, es sind 25)
## <font color='blue'>**Lösung**</font>
%% Cell type:code id:a13a6dc5-a537-4104-ae5c-6e6fb3700a69 tags:
``` python
```
%% Cell type:code id:b4c83fc4-ac7f-4384-a442-a7a268696085 tags:
``` python
```
%% Cell type:markdown id:5ac65721-daea-43d8-937c-021b2dfa8502 tags:
## Hinweise
Prinzipiell muss für jeden potentiellen Teiler überprüft werden, ob die Zahl teilbar ist. Um das herauszufinden kannst du den % Operator verwenden. Dieser gibt den Rest bei einer ganzzahligen Division aus. Ist der Rest für einen Teiler gleich 0, dann ist die Zahl keine Primzahl. Die Funktion kann an diesem Punkt beendet werden. Also je nachdem, ob der Rest gleich Null ist oder nicht, kann die Funktion mit negativem Ergebnis beendet werden, oder muss weiterlaufen. Wenn alle potentiellen Teiler probiert wurden und keiner die Zahl teilt, dann ist die Zahl eine Primzahl und die Funktion kann mit positivem Ergebnis beendet werde. Es ist also nötig, dass das Programm je nach Ergebnis unterschiedlich weiterläuft. Dieses Verhalten wird Verzweigung genannt. Im Grundlagen-Notebook wird erklärt, wie eine Verzweigung funktioniert. Beachte außerdem, dass 0 und 1 keine Primzahlen sind
%% Cell type:markdown id:f6f121ed-0501-42c8-bbf4-2dddb87d25cb tags:
# <font color='blue'>**Abschnitt 4 - Listen**</font>
%% Cell type:markdown id:2c306592-95a5-4c6c-a7e0-ce8499772057 tags:
## <font color='blue'>**Augabe**</font>
Schreibe eine Funktion "statistik", die eine Liste von Werten als Parameter erhält und von diesen Werten den Mittelwert und die Standardabweichung berechnet. Probiere die Funktion mit der Liste, die in der zweiten Zelle gegebenen Liste.\
(Zur Kontrolle, der Mittelwert ist ca. 0.516, die Standardabweichung liegt bei ca. 0.289)
## <font color='blue'>**Grundlagen**</font>
der Mittelwert einer Liste von $n$ Zahlen ist\
$\overline{x}=\frac{\sum_{i=1}^{n}(x_{i})}{ n}$\
Die Standardabweichung ist definiert als die Wurzel der Varianz, bzw. der durchschnittlichen quadratischen Abweichung der Werte vom Mittelwert\
$
\sigma=\sqrt{\frac{1}{n}\sum_{i=1}^{n}(x_{i}-\overline{x})^{2}}
$
## <font color='blue'>**Lösung**</font>
%% Cell type:code id:62f4cfe0-7e29-42eb-939f-87de2b568c13 tags:
``` python
```
%% Cell type:code id:12c1ee6c-2e1f-453f-b530-d89638bf1ecd tags:
``` python
vals=[0.6964376821627082, 0.26266291048512347, 0.6745158617205556, 0.5288863107123398, 0.9274827629604636, 0.5243575061460061, 0.13385032676535535, 0.5411765303585021, 0.8198672857283978, 0.520437008812458, 0.562041573670414, 0.8561634972894122, 0.9623313631899726, 0.31907914320612074, 0.26119438987542387, 0.13520243670788368, 0.09469575247376472, 0.4246904822161435, 0.9133966307845354, 0.6420660225100518, 0.5785388233096391, 0.5238427408012839, 0.6647315475249502, 0.23571241136003973, 0.05961979239799975, 0.2165498289343185, 0.27159399814957363, 0.7655112819065766, 0.3431093024220383, 0.032247101142615864, 0.3015891143198096, 0.8097960606785481, 0.6796579318567529, 0.04436335567039129, 0.3407031394453095, 0.9458530157190131, 0.4218758395390574, 0.800645477912877, 0.7122317776120418, 0.16153560000189693, 0.8135112166616905, 0.6482516503330767, 0.19497040057189519, 0.7385295095967741, 0.5853177365981909, 0.7420310625532276, 0.9973422543876882, 0.6452433133176014, 0.08077974197489635, 0.46872138143040165, 0.4054095407349284, 0.9820027392529405, 0.1336574018638953, 0.7951695379763538, 0.526730196167776, 0.5838599467003179, 0.0101539445719665, 0.48955298718235196, 0.03312143865023964, 0.8037955706420147, 0.3720197208314814, 0.48910812354462607, 0.24786536056996467, 0.1308221105399613, 0.041839203867548025, 0.9577432390272803, 0.5173227078055732, 0.6214831882992236, 0.2735357256248029, 0.6800368701292161, 0.7925116477725586, 0.9995034932317471, 0.5874671327858604, 0.862421214533514, 0.528701106919735, 0.812381203902576, 0.5914815145860267, 0.6983657416025035, 0.9147650053289076, 0.1193325169156918, 0.2749890766516555, 0.7890513406461243, 0.10338960814994036, 0.497040228474409, 0.7482023492365272, 0.5720468814904877, 0.4042269451026068, 0.9831530451459302, 0.15738865410556224, 0.05169634869621442, 0.6801435501291248, 0.3197438911718855, 0.01245122578094271, 0.6284172563073083, 0.9055888582598005, 0.7634333890207554, 0.8039480668851395, 0.03594773926272621, 0.5331691153755076, 0.7424130320454684]
statistik(vals)
```
%% Cell type:markdown id:764a11d8-b96c-471a-83c0-38765c41a5e3 tags:
## <font color='blue'>**Hintergründe**</font>
Es gibt in Python einen weiteren Variablentyp namens *list*. Listen sind Variablen, die mehrere Werte (potentiell unterschiedlichen Typs) zusammenfassen. Listen können also selbst aus Listen bestehen. Die einzelnen Werte dieser Liste sind über ihre Position innerhalb der Liste erreichbar (Zählung beginnt bei 0!). Um auf einen Wert der Liste zuzugreifen werden eckige Klammern verwendet. Man sagt, dass eine Liste indizierbar ist. Das erste Element hat den Index 0 nicht 1!
%% Cell type:code id:565d45c1-30f9-47bc-aed6-c95d29a744fd tags:
``` python
meineListe=[1,2,"hallo",9.9]
print(meineListe[0])
print(meineListe[2])
```
%% Output
1
hallo
%% Cell type:markdown id:8578e730-1027-4094-a423-91b0fabc0954 tags:
for-Schleifen können genutzt werden, um über die Elemente einer Liste zu iterieren. Dabei nimmt die Zählvariable dür Jeden durchlauf ein Element der Liste an
%% Cell type:code id:c0f9ea13-2d67-4921-8612-86108808225c tags:
``` python
eineListe=[4,"Apfel",3,9.3]
for x in eineListe:
print(x)
```
%% Output
4
Apfel
3
9.3
%% Cell type:markdown id:eb7d5ae9-3a54-44d2-a89a-b09d855df6eb tags:
Die einzelnen Einträge einer Liste sind veränderbar. Die Liste ist ein sogenanntes mutable-Object. Es können auch Elemente entfernt oder hinzugefügt werden
%% Cell type:code id:09a9d888-f5f2-4914-a803-594fd43d9f7c tags:
``` python
meineListe[1]="ein neuer Wert"
print(meineListe)
```
%% Output
[1, 'ein neuer Wert', 'hallo', 9.9]
%% Cell type:markdown id:ac5cea15-5204-44e6-bed9-882e408a8bde tags:
Auch Zeichenketten sind in Python indizierbar! Der Einzelbuchstabe an der betreffenden Position wird ausgegeben. Eine Zeichenkette ist allerdings immutable, die Buchstaben können nur gelesen werden. Die Zeichenkette lässt sich aber nicht verändern
%% Cell type:code id:13659f43-ff9d-4039-892e-d5aa01dcc773 tags:
``` python
Zeichenkette="ABCDEFG"
print("Der zweite Buchstabe der Zeichenkette ist: " +Zeichenkette[2])
```
%% Output
Der zweite Buchstabe der Zeichenkette ist: C
%% Cell type:code id:2582827c-b3a9-47df-9dc5-ab13064fe2e8 tags:
``` python
Zeichenkette[2]="A"#das Funktioniert nicht, da Zeichenketten nicht veränderbar sind
```
%% Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In [83], line 1
----> 1 Zeichenkette[2]="A"
TypeError: 'str' object does not support item assignment
%% Cell type:markdown id:af12b75c-a6e1-45b9-9b04-6d00b7a14bcf tags:
Generell kannst du dir merken, dass die Datentypen list, dict und alle selbst definierten Objekte (dazu kommen wir in der nächsten Übung) mutable-Objects sind, alle anderen Datentypen, wie auch die, die wir bereits kennengelernt haben, immutable-Objects sind. Diese Unterscheidung hat praktischen Einfluss auf die Verwendung von Variablen. Schaue dir das nächste Beispiel an
%% Cell type:code id:b138b8bb-6766-4e77-ba01-8606459aa438 tags:
``` python
var1=9
Liste1=[1,2,3,4,5]
Liste2=Liste1
var2=var1
var2=12
Liste2[0]=9
print (var1)
print (Liste1)
```
%% Output
9
[9, 2, 3, 4, 5]
%% Cell type:markdown id:01035473-7d4c-4e0b-9bee-20e93522cd48 tags:
In diesem Beispiel scheint es, als ob die Zuweisung bei Listen etwas anderes tut, als bei anderen Variablen. Das stimmt nicht ganz. Im Grundsatz folgt die Zuweisung einer etwas anderen Idee. Du kannst dir das Verhalten so vorstellen, dass das Literal '9' ein ganze Zahl mit dem Wer 9 erzeugt. Das ist ein immutable-Objekt, daher bleibt es immer eine 9. Die Zuweisung 'var2=var1' hat zur Folge, dass *var2* und *var1* auf die selbe 9 verweisen, also zwei Namen für die selbe 9 sind. Eine erneute Zuweisung 'var2=12' hat zur Folge, dass eine ganze Zahl 12 erzeugt wird und *var2* auf die neu erzeugte 12 verweist, *var1* aber weiterhin auf die 9. Bei den Listen ist es genau so. Nur das die Liste eben veränderbar ist. Weißt du der Variable *Liste2* einen neuen Wert zu, dann verändert das die Liste, auf die *Liste1* verweist nicht.
%% Cell type:code id:ecc55c5d-e9d2-40aa-b2bd-189f176c19be tags:
``` python
Liste2=5
print("Liste2 ist jetzt eine Zahl mit dem Wert ",Liste2)
print("Liste1 ist weiterhin die Liste",Liste1)
```
%% Output
Liste2 ist jetzt eine Zahl mit dem Wert 5
Liste1 ist weiterhin die Liste [9, 2, 3, 4, 5]
%% Cell type:markdown id:434bd101-84bc-49d4-9cf6-7060aa1208ed tags:
Manchmal möchtest du allerdings, dass bei der Zuweisung eine Liste wirklich kopiert wird. Dafür gibt es zwei Möglichkeiten. Das erste Beispiel nutzt aus, dass Slicing immer eine Kopie erzeugt und ist eine Art kurze Schreibweise. Quellcode dieser Art kommt in Python Programmen häufig vor
%% Cell type:code id:2c4d9b94-1a38-450f-b108-7ba9b9ace6c8 tags:
``` python
Liste1=[1,2,3,4,5]
Liste2=Liste1[:]
Liste2[0]=9
print (Liste1)
```
%% Output
[1, 2, 3, 4, 5]
%% Cell type:code id:1fb4d0ec-a224-446b-8796-77acdb4650eb tags:
``` python
Liste1=[1,2,3,4,5]
Liste2=list(Liste1)
Liste2[0]=9
print (Liste1)
```
%% Output
[1, 2, 3, 4, 5]
%% Cell type:markdown id:b31bc586-1c3f-4220-a7af-eeed643df660 tags:
Der Effekt, dass die Zuweisung nicht wirklich eine Kopie ist, ist in dieser Form meist nicht sonderlich hilfreich. Allerdings kann man das Verhalten im Kontext von Funktionen nutzen
%% Cell type:code id:12ab3408-fcab-4cd4-a96a-7114e4cd02fe tags:
``` python
def meineFunktion(parameter):
parameter[0]=10
meineListe=[1,2,3,4,5]
meineFunktion(meineListe)
print(meineListe)
```
%% Output
[10, 2, 3, 4, 5]
%% Cell type:markdown id:73036041-e0cd-48c8-8d8b-2a751e48413d tags:
Wie oben beschrieben funktioniert das erstellen der Parameter-Variablen wie eine Zuweisung, es folgt also den gleichen Regeln.
Hier siehst du schon ein Beispiel, wie globale Variablen vermieden werden können. Die Liste kann innerhalb der Funktion verändert werden. Da die Funktion die Liste allerdings als Parameter übergeben bekommt, ist besser verständlich, wieso sie auch innerhalb der Funktion veränderbar ist.
%% Cell type:markdown id:595a83db-5a61-4048-84d3-e5f1ca14c263 tags:
# <font color='blue'>**Aufgabe zum selbst probieren**</font>
%% Cell type:markdown id:ca559a03-b79b-4f1a-a128-4e3e3e177017 tags:
Versuche in einem Programm Alle Primzahlen bis zur 100.000 zu finden. Das Wird nicht mehr mit dem oben programmierten Primzahltest funktionieren, da zu viele Probedivisionen durchgeführt werden müssen. Es gibt eine Methode, die Primzahlen schneller zu identifizieren, wenn man die Primfaktorzerlegung als Ausgangspunkt nimmt. Jede nicht-Primzahl $n$ ist durch eine Primzahl $p$ mit $2\le$p$\le\sqrt{n}$ ganzzahlig teilbar. Damit muss ausgehend von der 2, die bekanntermaßen die erste Primzahl ist, eine Liste geführt werden, welche Primzahlen bereits gefunden wurden. So kann man ausgehend von der 3 jede Zahl nacheinander darauf testen, ob sie eine Primzahl ist. Falls dir die Beschreibung nicht reicht einen Algorithmus zu entwickeln, gibt es in der nächsten Zelle noch einige Hinweise. (Es gibt bis 100.000 9.592 Primzahlen. Bis 1.000.000 sind es 78.498, das kannst du mit diesem Algorithmus auch herausfinden; probiere das aber bitte nicht auf dem GITZ-Server aus, auf deinem Laptop sollte es jedoch kein Problem sein)
## <font color='blue'>**Lösung**</font>
%% Cell type:code id:6a4e935d-1468-41be-a175-71505b044a38 tags:
``` python
```
%% Cell type:code id:59d7ecb7-feec-40a9-a3a5-a93dacdcec76 tags:
``` python
```
%% Cell type:markdown id:0109a144-56cc-40a7-8457-df445d8b92ae tags:
## <font color='blue'>**Hinweise - falls du nicht weißt, wie du anfangen sollst**</font>
Zu erst einmal musst du alle Primzahlen finden und benötigst die Gefundenen später auch noch. Also brauchst du eine Liste, um gefundene Primzahlen zu speichern. Die sollte am Anfang, wie oben beschrieben, bereits die 2 enthalten.\
Anschließend musst du bei jeder Zahl von 3 bis 100.000 testen, ob sie eine Primzahl ist. Falls ja, musst du sie hinten an die Liste der bekannten Primzahlen anhängen.\
Für den Test schreibst du am besten eine Funktion. Die benötigt als Parameter die Zahl n, die du testen möchtest und die Liste der bekannten Primzahlen. diese Funktion muss alle Elemente der Liste durchlaufen. Für jedes Element überprüfst du, ob n durch das Element restlos teilbar ist. Falls ja, dann ist n keine Primzahl. Anschließend überprüfst du, ob das Element größer als $\sqrt{n}$ ist, falls ja ist n eine Primzahl. Das funktioniert, da die Liste nach größe aufsteigend sortiert angelegt wurde. Die restlichen Elemente müssen gar nicht mehr getestet werden, da die Zahl n nicht ganzzahlig durch sie teilbar sein kann. Falls die Schleife über die Elemente das Ende der Primzahlen erreicht, dann ist n auch eine Primzahl, da kein Teiler gefunden wurde
%% Cell type:markdown id:34903ede-f475-4cf9-a5ff-29840f89f44f tags:
# <font color='blue'>**Beispiel zum nachvollziehen**</font>
die folgende Funktion berechnet auf eine andere Art eine beliebige Fibonacci-Zahl. Sie funktioniert sogar für die erste und Zweite. Kannst du nachvollziehen, wieso sie funktioniert?
%% Cell type:code id:0e29c3dd-bd64-4e61-a1f5-5d17bb1e44ac tags:
``` python
def Fib(n):
if n<1:
print ("Die Reihe der Fibonacci-Zahlen beginnt mit der ersten Zahl!")
return
if n==1:
return 0
if n==2:
return 1
return Fib(n-2)+Fib(n-1)
```
%% Cell type:code id:57b03415-9dfb-4a08-9733-5cdfc6e6a782 tags:
``` python
Fib(6)
```
%% Output
5
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment